Threads.h revision 8ed196ac0f4aa8ae811c012dfa6f596fddebf1bf
19066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 29066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** 39066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** Copyright 2012, The Android Open Source Project 49066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** 569a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** Licensed under the Apache License, Version 2.0 (the "License"); 669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** you may not use this file except in compliance with the License. 769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** You may obtain a copy of the License at 89066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** 969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** http://www.apache.org/licenses/LICENSE-2.0 109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** 1169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** Unless required by applicable law or agreed to in writing, software 1269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** distributed under the License is distributed on an "AS IS" BASIS, 1369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1469a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes** See the License for the specific language governing permissions and 159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project** limitations under the License. 169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project*/ 179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#ifndef INCLUDING_FROM_AUDIOFLINGER_H 199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project #error This header file should only be included from AudioFlinger.h 209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#endif 210795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopian 220795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopianclass ThreadBase : public Thread { 230795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopianpublic: 24f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten 259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "TrackBase.h" 269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project enum type_t { 289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MIXER, // Thread class is MixerThread 299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project DIRECT, // Thread class is DirectOutputThread 309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project DUPLICATING, // Thread class is DuplicatingThread 319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project RECORD, // Thread class is RecordThread 329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project OFFLOAD, // Thread class is OffloadThread 339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MMAP // control thread for MMAP stream 349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // If you add any values here, also update ThreadBase::threadTypeToString() 359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const char *threadTypeToString(type_t type); 389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_devices_t outDevice, audio_devices_t inDevice, type_t type, 416af763bec7c3f4d50fee8dd0046409bb8a7fe8f6Glenn Kasten bool systemReady); 429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~ThreadBase(); 43957e58670baad8c5995f1368e3b5280f0dbd891fSan Mehat 44160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual status_t readyToRun(); 45a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat 469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void dumpBase(int fd, const Vector<String16>& args); 479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void dumpEffectChains(int fd, const Vector<String16>& args); 48160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 49160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate void clearPowerManager(); 50160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 51160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // base for record and playback 52160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate enum { 53f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten CFG_EVENT_IO, 54f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten CFG_EVENT_PRIO, 556793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten CFG_EVENT_SET_PARAMETER, 569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project CFG_EVENT_CREATE_AUDIO_PATCH, 579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project CFG_EVENT_RELEASE_AUDIO_PATCH, 589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class ConfigEventData: public RefBase { 619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~ConfigEventData() {} 639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dump(char *buffer, size_t size) = 0; 659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project protected: 669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ConfigEventData() {} 679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Config event sequence by client if status needed (e.g binder thread calling setParameters()): 709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event 719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 2. Lock mLock 729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal 739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 4. sendConfigEvent_l() reads status from event->mStatus; 749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 5. sendConfigEvent_l() returns status 759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 6. Unlock 766793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten // 77e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // Parameter sequence by server: threadLoop calling processConfigEvents_l(): 78e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 1. Lock mLock 79e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 2. If there is an entry in mConfigEvents proceed ... 80e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 3. Read first entry in mConfigEvents 81e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 4. Remove first entry from mConfigEvents 82e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 5. Process 83e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 6. Set event->mStatus 84e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 7. event->mCond.signal 85e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat // 8. Unlock 86e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat 87e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat class ConfigEvent: public RefBase { 88e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat public: 89e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat virtual ~ConfigEvent() {} 90e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat 91e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat void dump(char *buffer, size_t size) { mData->dump(buffer, size); } 92e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat 93e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat const int mType; // event type e.g. CFG_EVENT_IO 94e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat Mutex mLock; // mutex associated with mCond 95e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat Condition mCond; // condition for status return 96e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat status_t mStatus; // status communicated to sender 979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mWaitStatus; // true if sender is waiting for status 989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mRequiresSystemReady; // true if must wait for system ready to enter event queue 999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project sp<ConfigEventData> mData; // event specific parameter data 1009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project protected: 10280b12fcaaec458377d966803c3a61504f0897ea1Romain Guy explicit ConfigEvent(int type, bool requiresSystemReady = false) : 10380b12fcaaec458377d966803c3a61504f0897ea1Romain Guy mType(type), mStatus(NO_ERROR), mWaitStatus(false), 10480b12fcaaec458377d966803c3a61504f0897ea1Romain Guy mRequiresSystemReady(requiresSystemReady), mData(NULL) {} 10580b12fcaaec458377d966803c3a61504f0897ea1Romain Guy }; 10680b12fcaaec458377d966803c3a61504f0897ea1Romain Guy 1079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class IoConfigEventData : public ConfigEventData { 1089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project IoConfigEventData(audio_io_config_event event, pid_t pid) : 1109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mEvent(event), mPid(pid) {} 1119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dump(char *buffer, size_t size) { 1139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project snprintf(buffer, size, "IO event: event %d\n", mEvent); 114887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn } 1159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const audio_io_config_event mEvent; 1179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const pid_t mPid; 1189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes class IoConfigEvent : public ConfigEvent { 1219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project IoConfigEvent(audio_io_config_event event, pid_t pid) : 12369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes ConfigEvent(CFG_EVENT_IO) { 1249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mData = new IoConfigEventData(event, pid); 1259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~IoConfigEvent() {} 1279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class PrioConfigEventData : public ConfigEventData { 1309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) : 1329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {} 1339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dump(char *buffer, size_t size) { 1359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project snprintf(buffer, size, "Prio event: pid %d, tid %d, prio %d, for app? %d\n", 1369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mPid, mTid, mPrio, mForApp); 1379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const pid_t mPid; 1409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const pid_t mTid; 1419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const int32_t mPrio; 1429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const bool mForApp; 1439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class PrioConfigEvent : public ConfigEvent { 1469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) : 1489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ConfigEvent(CFG_EVENT_PRIO, true) { 1499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mData = new PrioConfigEventData(pid, tid, prio, forApp); 1509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 15169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual ~PrioConfigEvent() {} 1529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 15469a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes class SetParameterConfigEventData : public ConfigEventData { 1559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project explicit SetParameterConfigEventData(String8 keyValuePairs) : 1579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mKeyValuePairs(keyValuePairs) {} 1589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dump(char *buffer, size_t size) { 1609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project snprintf(buffer, size, "KeyValue: %s\n", mKeyValuePairs.string()); 1619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const String8 mKeyValuePairs; 1649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class SetParameterConfigEvent : public ConfigEvent { 1679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project explicit SetParameterConfigEvent(String8 keyValuePairs) : 1699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ConfigEvent(CFG_EVENT_SET_PARAMETER) { 1709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mData = new SetParameterConfigEventData(keyValuePairs); 1719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mWaitStatus = true; 1729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~SetParameterConfigEvent() {} 1749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 1759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class CreateAudioPatchConfigEventData : public ConfigEventData { 1779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 1789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project CreateAudioPatchConfigEventData(const struct audio_patch patch, 179f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten audio_patch_handle_t handle) : 180e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat mPatch(patch), mHandle(handle) {} 181f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten 182f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten virtual void dump(char *buffer, size_t size) { 183f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten snprintf(buffer, size, "Patch handle: %u\n", mHandle); 184887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn } 185f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten 186e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat const struct audio_patch mPatch; 187e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat audio_patch_handle_t mHandle; 188e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat }; 18969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 1903e458241d9930465a20a861ecb42744355d48e48San Mehat class CreateAudioPatchConfigEvent : public ConfigEvent { 191f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten public: 1923e458241d9930465a20a861ecb42744355d48e48San Mehat CreateAudioPatchConfigEvent(const struct audio_patch patch, 1933e458241d9930465a20a861ecb42744355d48e48San Mehat audio_patch_handle_t handle) : 1943e458241d9930465a20a861ecb42744355d48e48San Mehat ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) { 1953e458241d9930465a20a861ecb42744355d48e48San Mehat mData = new CreateAudioPatchConfigEventData(patch, handle); 1963e458241d9930465a20a861ecb42744355d48e48San Mehat mWaitStatus = true; 197f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten } 1986793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten virtual ~CreateAudioPatchConfigEvent() {} 1993e458241d9930465a20a861ecb42744355d48e48San Mehat }; 2003e458241d9930465a20a861ecb42744355d48e48San Mehat 2013e458241d9930465a20a861ecb42744355d48e48San Mehat class ReleaseAudioPatchConfigEventData : public ConfigEventData { 202f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten public: 203f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) : 204f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten mHandle(handle) {} 205f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten 206f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten virtual void dump(char *buffer, size_t size) { 207f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten snprintf(buffer, size, "Patch handle: %u\n", mHandle); 208f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten } 209a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat 210a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat audio_patch_handle_t mHandle; 211a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat }; 212a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat 213a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat class ReleaseAudioPatchConfigEvent : public ConfigEvent { 214a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat public: 215a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) : 216a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) { 217a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat mData = new ReleaseAudioPatchConfigEventData(handle); 218a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat mWaitStatus = true; 219a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat } 220a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat virtual ~ReleaseAudioPatchConfigEvent() {} 221a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat }; 22269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 223f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten class PMDeathRecipient : public IBinder::DeathRecipient { 2245baa3a62a97544669fba6d65a11c07f252e654ddSteve Block public: 225a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} 2265baa3a62a97544669fba6d65a11c07f252e654ddSteve Block virtual ~PMDeathRecipient() {} 227a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat 228a5109a878eeff22e32ee5ce1b1cd15e8daad5234San Mehat // IBinder::DeathRecipient 2293e458241d9930465a20a861ecb42744355d48e48San Mehat virtual void binderDied(const wp<IBinder>& who); 2303e458241d9930465a20a861ecb42744355d48e48San Mehat 2311fd0ec738b0a2b97cc28701aa37b1a9869afc684San Mehat private: 2321fd0ec738b0a2b97cc28701aa37b1a9869afc684San Mehat DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient); 2336793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten 2343e458241d9930465a20a861ecb42744355d48e48San Mehat wp<ThreadBase> mThread; 2353e458241d9930465a20a861ecb42744355d48e48San Mehat }; 2363e458241d9930465a20a861ecb42744355d48e48San Mehat 2373e458241d9930465a20a861ecb42744355d48e48San Mehat virtual status_t initCheck() const = 0; 2387e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat 2397e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat // static externally-visible 2407e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat type_t type() const { return mType; } 2413e458241d9930465a20a861ecb42744355d48e48San Mehat bool isDuplicating() const { return (mType == DUPLICATING); } 2423e458241d9930465a20a861ecb42744355d48e48San Mehat 2437e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat audio_io_handle_t id() const { return mId;} 2447e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat 2457e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat // dynamic externally-visible 2463762c311729fe9f3af085c14c5c1fb471d994c03Steve Block uint32_t sampleRate() const { return mSampleRate; } 2477e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat audio_channel_mask_t channelMask() const { return mChannelMask; } 2487e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat audio_format_t format() const { return mHALFormat; } 2491fd0ec738b0a2b97cc28701aa37b1a9869afc684San Mehat uint32_t channelCount() const { return mChannelCount; } 25007b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects, 25107b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten // and returns the [normal mix] buffer's frame count. 25207b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten virtual size_t frameCount() const = 0; 25307b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten 25407b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten // Return's the HAL's frame count i.e. fast mixer buffer size. 25507b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten size_t frameCountHAL() const { return mFrameCount; } 25607b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten 25707b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten size_t frameSize() const { return mFrameSize; } 25807b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten 2597e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat // Should be "virtual status_t requestExitAndWait()" and override same 26007b0465095bd9ab3412caefa4fcacbdc3825c64bGlenn Kasten // method in Thread, but Thread::requestExitAndWait() is not yet virtual. 261f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten void exit(); 262f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten virtual bool checkForNewParameter_l(const String8& keyValuePair, 263f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten status_t& status) = 0; 264f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten virtual status_t setParameters(const String8& keyValuePairs); 2657e63789a0e0689d940609b1daceebc1bc08dcbefSan Mehat virtual String8 getParameters(const String8& keys) = 0; 26669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0) = 0; 267f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten // sendConfigEvent_l() must be called with ThreadBase::mLock held 268f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten // Can temporarily release the lock if waiting for a reply from 269f1b56449f58963e4f0473d5e26961f68c31759f4Glenn Kasten // processConfigEvents_l(). 2700a42b811aea490a9a605b75f0320101f6eafd283San Mehat status_t sendConfigEvent_l(sp<ConfigEvent>& event); 271242d65bf9faf1d2bc3468490e510551140e23462San Mehat void sendIoConfigEvent(audio_io_config_event event, pid_t pid = 0); 2723e458241d9930465a20a861ecb42744355d48e48San Mehat void sendIoConfigEvent_l(audio_io_config_event event, pid_t pid = 0); 2733e458241d9930465a20a861ecb42744355d48e48San Mehat void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp); 2743e458241d9930465a20a861ecb42744355d48e48San Mehat void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp); 2753e458241d9930465a20a861ecb42744355d48e48San Mehat status_t sendSetParameterConfigEvent_l(const String8& keyValuePair); 2769e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch, 2779e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey audio_patch_handle_t *handle); 2789e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle); 2799e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey void processConfigEvents_l(); 2809e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey virtual void cacheParameters_l() = 0; 2819e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey virtual status_t createAudioPatch_l(const struct audio_patch *patch, 2829e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey audio_patch_handle_t *handle) = 0; 2839e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0; 2849e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey virtual void getAudioPortConfig(struct audio_port_config *config) = 0; 285160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 286160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 287160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // see note at declaration of mStandby, mOutDevice and mInDevice 288160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate bool standby() const { return mStandby; } 28971f2cf116aab893e224056c38ab146bd1538dd3eSteve Block audio_devices_t outDevice() const { return mOutDevice; } 290160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate audio_devices_t inDevice() const { return mInDevice; } 291160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate audio_devices_t getDevice() const { return isOutput() ? mOutDevice : mInDevice; } 292160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 293160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual bool isOutput() const = 0; 294160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 295160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual sp<StreamHalInterface> stream() const = 0; 296160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate 297160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate sp<EffectHandle> createEffect_l( 298160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate const sp<AudioFlinger::Client>& client, 299160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate const sp<IEffectClient>& effectClient, 300160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate int32_t priority, 301160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate audio_session_t sessionId, 3026793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten effect_descriptor_t *desc, 3036793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten int *enabled, 3046793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten status_t *status /*non-NULL*/, 305cc767191cfb675f744e0165608b0a4196aba2b37Glenn Kasten bool pinned); 3066793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten 3076793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten // return values for hasAudioSession (bit field) 3086793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten enum effect_state { 3096793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten EFFECT_SESSION = 0x1, // the audio session corresponds to at least one 3106793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten // effect 3116793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten TRACK_SESSION = 0x2, // the audio session corresponds to at least one 312cc767191cfb675f744e0165608b0a4196aba2b37Glenn Kasten // track 313cc767191cfb675f744e0165608b0a4196aba2b37Glenn Kasten FAST_SESSION = 0x4 // the audio session corresponds to at least one 314cc767191cfb675f744e0165608b0a4196aba2b37Glenn Kasten // fast track 3156793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten }; 3166793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten 3179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // get effect chain corresponding to session Id. 3189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project sp<EffectChain> getEffectChain(audio_session_t sessionId); 3199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // same as getEffectChain() but must be called with ThreadBase mutex locked 320160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const; 321160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // add an effect chain to the chain list (mEffectChains) 322160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; 323160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // remove an effect chain from the chain list (mEffectChains) 324160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; 325160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // lock all effect chains Mutexes. Must be called before releasing the 326160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // ThreadBase mutex before processing the mixer and effects. This guarantees the 3273762c311729fe9f3af085c14c5c1fb471d994c03Steve Block // integrity of the chains during the process. 328160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // Also sets the parameter 'effectChains' to current value of mEffectChains. 329160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains); 330160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // unlock effect chains after process 331160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains); 332160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // get a copy of mEffectChains vector 333160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; }; 334160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate // set audio mode to all effect chains 335887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn void setMode(audio_mode_t mode); 336887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn // get effect module with corresponding ID on specified audio session 337887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId); 3386793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId); 339887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn // add and effect module. Also creates the effect chain is none exists for 3406793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten // the effects audio session 341887f355f99ff83d568ef2885a4fdcaae475583dfDianne Hackborn status_t addEffect_l(const sp< EffectModule>& effect); 3429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // remove and effect module. Also removes the effect chain is this was the last 34369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // effect 3446215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block void removeEffect_l(const sp< EffectModule>& effect, bool release = false); 3459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // disconnect an effect handle from module and destroy module if last handle 3469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast); 3479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // detach all tracks connected to an auxiliary effect 3489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void detachAuxEffect_l(int effectId __unused) {} 3499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // returns a combination of: 3509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // - EFFECT_SESSION if effects on this audio session exist in one chain 3519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // - TRACK_SESSION if tracks on this audio session exist 3529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // - FAST_SESSION if fast tracks on this audio session exist 3539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0; 3549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t hasAudioSession(audio_session_t sessionId) const { 3559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Mutex::Autolock _l(mLock); 3569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return hasAudioSession_l(sessionId); 3579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // the value returned by default implementation is not important as the 3609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // strategy is only meaningful for PlaybackThread which implements this method 3616793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused) 3629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project { return 0; } 3636215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block 3649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // check if some effects must be suspended/restored when an effect is enabled 3659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // or disabled 3669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 3679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool enabled, 3689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId = 3699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project AUDIO_SESSION_OUTPUT_MIX); 3709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, 37110e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown bool enabled, 37210e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown audio_session_t sessionId = 37310e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown AUDIO_SESSION_OUTPUT_MIX); 37410e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown 37510e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0; 37610e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0; 37710e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown 3789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Return a reference to a per-thread heap which can be used to allocate IMemory 37910e89712863f5b91a2982dc1783fbdfe39c1485dJeff Brown // objects that will be read-only to client processes, read/write to mediaserver, 3809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // and shared by all client processes of the thread. 3819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // The heap is per-thread rather than common across all threads, because 3829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // clients can't be trusted not to modify the offset of the IMemory they receive. 3839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // If a thread does not have such a heap, this method returns 0. 3849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual sp<MemoryDealer> readOnlyHeap() const { return 0; } 3859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual sp<IMemory> pipeMemory() const { return 0; } 38769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 3889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void systemReady(); 3899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 39069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // checkEffectCompatibility_l() must be called with ThreadBase::mLock held 3919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 3929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId) = 0; 3939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void broadcast_l(); 3959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mutable Mutex mLock; 3979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprotected: 3999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // entry describing an effect being suspended in mSuspendedSessions keyed vector 4019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class SuspendedSessionDesc : public RefBase { 4029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 4039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SuspendedSessionDesc() : mRefCount(0) {} 4049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int mRefCount; // number of active suspend requests 4069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project effect_uuid_t mType; // effect type UUID 4079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 4089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void acquireWakeLock(); 4109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void acquireWakeLock_l(); 4119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void releaseWakeLock(); 4129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void releaseWakeLock_l(); 4139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void updateWakeLockUids_l(const SortedVector<uid_t> &uids); 4149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void getPowerManager_l(); 4156215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block // suspend or restore effects of the specified type (or all if type is NULL) 4169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // on a given session. The number of suspend requests is counted and restore 4179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // occurs when all suspend requests are cancelled. 4189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void setEffectSuspended_l(const effect_uuid_t *type, 41959325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn bool suspend, 4209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId); 4219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // updated mSuspendedSessions when an effect is suspended or restored 42269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes void updateSuspendedSessions_l(const effect_uuid_t *type, 4239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool suspend, 4248564c8da817a845353d213acd8636b76f567b234Steve Block audio_session_t sessionId); 4259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // check if some effects must be suspended when an effect chain is added 4269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); 42769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 4289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project String16 getWakeLockTag(); 4299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void preExit() { } 43169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void setMasterMono_l(bool mono __unused) { } 4329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool requireMonoBlend() { return false; } 4338564c8da817a845353d213acd8636b76f567b234Steve Block 4349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project friend class AudioFlinger; // for mEffectChains 4359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const type_t mType; 4379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Used by parameters, config events, addTrack_l, exit 4390bca96bcbfe559f9330a01f723c5c9cba51ec05aMarco Nelissen Condition mWaitWorkCV; 44069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 4419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const sp<AudioFlinger> mAudioFlinger; 44259325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn 4439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // updated by PlaybackThread::readOutputParameters_l() or 4449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // RecordThread::readInputParameters_l() 4459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t mSampleRate; 4469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t mFrameCount; // output HAL, direct output, record 4479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_channel_mask_t mChannelMask; 4489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t mChannelCount; 4499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t mFrameSize; 4509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // not HAL frame size, this is for output sink (to pipe to fast mixer) 4519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_format_t mFormat; // Source format for Recording and 4529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Sink format for Playback. 4539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Sink format may be different than 4549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // HAL format if Fastmixer is used. 4550bca96bcbfe559f9330a01f723c5c9cba51ec05aMarco Nelissen audio_format_t mHALFormat; 4569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t mBufferSize; // HAL buffer size for read() or write() 4579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Vector< sp<ConfigEvent> > mConfigEvents; 4599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready 4609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // These fields are written and read by thread itself without lock or barrier, 4629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // and read by other threads without lock or barrier via standby(), outDevice() 46369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // and inDevice(). 4649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Because of the absence of a lock or barrier, any other thread that reads 4659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // these fields must use the information in isolation, or be prepared to deal 4669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // with possibility that it might be inconsistent with other information. 46759325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn bool mStandby; // Whether thread is currently in standby. 46859325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn audio_devices_t mOutDevice; // output device 46959325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn audio_devices_t mInDevice; // input device 47059325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn audio_devices_t mPrevOutDevice; // previous output device 47159325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn audio_devices_t mPrevInDevice; // previous input device 47259325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn struct audio_patch mPatch; 47359325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn audio_source_t mAudioSource; 47459325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn 47559325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn const audio_io_handle_t mId; 47659325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn Vector< sp<EffectChain> > mEffectChains; 47759325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn 47859325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit 47959325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated 48059325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn sp<IPowerManager> mPowerManager; 4819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project sp<IBinder> mWakeLockToken; 4829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const sp<PMDeathRecipient> mDeathRecipient; 4839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // list of suspended effects per session and per type. The first (outer) vector is 4846215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block // keyed by session ID, the second (inner) by type UUID timeLow field 48569a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // Updated by updateSuspendedSessions_l() only. 4869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > > 48769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes mSuspendedSessions; 4889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // TODO: add comment and adjust size as needed 4899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const size_t kLogSize = 4 * 1024; 49069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes sp<NBLog::Writer> mNBLogWriter; 4919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mSystemReady; 4929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ExtendedTimestamp mTimestamp; 4939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // A condition that must be evaluated by the thread loop has changed and 4949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // we must not wait for async write callback in the thread loop before evaluating it 4959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mSignalPending; 4969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 49769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // ActiveTracks is a sorted vector of track type T representing the 4989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // active tracks of threadLoop() to be considered by the locked prepare portion. 4999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // ActiveTracks should be accessed with the ThreadBase lock held. 5009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 5019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // During processing and I/O, the threadLoop does not hold the lock; 5029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // hence it does not directly use ActiveTracks. Care should be taken 50369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // to hold local strong references or defer removal of tracks 5049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // if the threadLoop may still be accessing those tracks due to mix, etc. 5059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 50669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // This class updates power information appropriately. 5079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 5089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project template <typename T> 5109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project class ActiveTracks { 5116215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block public: 5129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project explicit ActiveTracks(SimpleLog *localLog = nullptr) 51369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes : mActiveTracksGeneration(0) 5149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project , mLastActiveTracksGeneration(0) 5159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project , mLocalLog(localLog) 5169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project { } 5179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ~ActiveTracks() { 51969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes ALOGW_IF(!mActiveTracks.isEmpty(), 5209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project "ActiveTracks should be empty in destructor"); 5219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // returns the last track added (even though it may have been 52369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // subsequently removed from ActiveTracks). 5249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 5259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Used for DirectOutputThread to ensure a flush is called when transitioning 5269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // to a new track (even though it may be on the same session). 5279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Used for OffloadThread to ensure that volume and mixer state is 52869a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // taken from the latest track added. 5296215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block // 5309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // The latest track is saved with a weak pointer to prevent keeping an 5319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // otherwise useless track alive. Thus the function will return nullptr 5329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // if the latest track has subsequently been removed and destroyed. 53369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes sp<T> getLatest() { 5349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mLatestActiveTrack.promote(); 53569a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes } 5369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // SortedVector methods 5389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ssize_t add(const sp<T> &track); 5399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ssize_t remove(const sp<T> &track); 5409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t size() const { 54169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes return mActiveTracks.size(); 5429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5438564c8da817a845353d213acd8636b76f567b234Steve Block ssize_t indexOf(const sp<T>& item) { 5449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mActiveTracks.indexOf(item); 5459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project sp<T> operator[](size_t index) const { 54769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes return mActiveTracks[index]; 5489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 54969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes typename SortedVector<sp<T>>::iterator begin() { 5509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mActiveTracks.begin(); 5519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project typename SortedVector<sp<T>>::iterator end() { 5536215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block return mActiveTracks.end(); 5549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Due to Binder recursion optimization, clear() and updatePowerState() 5579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // cannot be called from a Binder thread because they may call back into 558add868cebaf62cffe96e79764ea0b7f2320a03ebAmith Yamasani // the original calling process (system server) for BatteryNotifier 5599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // (which requires a Java environment that may not be present). 5609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Hence, call clear() and updatePowerState() only from the 5619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // ThreadBase thread. 5629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void clear(); 5639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // periodically called in the threadLoop() to update power state uids. 5649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void updatePowerState(sp<ThreadBase> thread, bool force = false); 5659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private: 5679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void logTrack(const char *funcName, const sp<T> &track) const; 5686215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block 5699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SortedVector<uid_t> getWakeLockUids() { 5709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SortedVector<uid_t> wakeLockUids; 5719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (const sp<T> &track : mActiveTracks) { 5729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project wakeLockUids.add(track->uid()); 5739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return wakeLockUids; // moved by underlying SharedBuffer 5759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>> 5789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mBatteryCounter; 5799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SortedVector<sp<T>> mActiveTracks; 5809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int mActiveTracksGeneration; 5819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int mLastActiveTracksGeneration; 58269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes wp<T> mLatestActiveTrack; // latest track added to ActiveTracks 5839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SimpleLog * const mLocalLog; 5849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 5858564c8da817a845353d213acd8636b76f567b234Steve Block 5869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SimpleLog mLocalLog; 58769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes}; 5886215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block 5899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectclass VolumeInterface { 5909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public: 5919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~VolumeInterface() {} 5939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setMasterVolume(float value) = 0; 5959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setMasterMute(bool muted) = 0; 59669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0; 5979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0; 5989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual float streamVolume(audio_stream_type_t stream) const = 0; 59969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 6009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project}; 6019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project// --- PlaybackThread --- 6039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectclass PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback, 6049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public VolumeInterface { 60569a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughespublic: 6069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 60769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes#include "PlaybackTracks.h" 6089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 60969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes enum mixer_state { 6109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MIXER_IDLE, // no active tracks 6119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready 6129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MIXER_TRACKS_READY, // at least one active track, and at least one track has data 61369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes MIXER_DRAIN_TRACK, // drain currently playing track 6149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MIXER_DRAIN_ALL, // fully drain the hardware 6159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // standby mode does not have an enum value 6169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // suspend by audio policy manager is orthogonal to mixer state 6179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 6189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // retry count before removing active track in case of underrun on offloaded thread: 62069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // we need to make sure that AudioTrack client has enough time to send large buffers 6219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is 62269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // handled for offloaded tracks 6239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const int8_t kMaxTrackRetriesOffload = 20; 6249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const int8_t kMaxTrackStartupRetriesOffload = 100; 6259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const int8_t kMaxTrackStopRetriesOffload = 2; 6269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static constexpr uint32_t kMaxTracksPerUid = 40; 6279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise 6299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // if delay is greater, the estimated time for timeLoopNextNs is reset. 6309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // This allows for catch-up to be done for small delays, while resetting the estimate 63169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // for initial conditions or large delays. 6329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project static const nsecs_t kMaxNextBufferDelayNs = 100000000; 6339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6346215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 6359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_io_handle_t id, audio_devices_t device, type_t type, bool systemReady); 6369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ~PlaybackThread(); 6379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void dump(int fd, const Vector<String16>& args); 6399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Thread virtuals 6419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool threadLoop(); 6429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // RefBase 6449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void onFirstRef(); 6459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 6479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId); 6489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprotected: 6509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Code snippets that were lifted up out of threadLoop() 6519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_mix() = 0; 65269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void threadLoop_sleepTime() = 0; 6539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ssize_t threadLoop_write(); 6549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_drain(); 6559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_standby(); 65669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void threadLoop_exit(); 6579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove); 65869a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 6599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // prepareTracks_l reads and writes mActiveTracks, and returns 6609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller 6619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // is responsible for clearing or destroying this Vector later on, when it 66269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // is safe to do so. That will drop the final ref count and destroy the tracks. 6639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0; 6649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void removeTracks_l(const Vector< sp<Track> >& tracksToRemove); 6659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // StreamOutHalInterfaceCallback implementation 66769a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void onWriteReady(); 6689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void onDrainReady(); 6699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void onError(); 6709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 67169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes void resetWriteBlocked(uint32_t sequence); 6729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void resetDraining(uint32_t sequence); 6739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool waitingAsyncCallback(); 6759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool waitingAsyncCallback_l(); 6769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool shouldStandby_l(); 6779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void onAddNewTrack_l(); 6789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void onAsyncError(); // error reported by AsyncCallbackThread 6799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // ThreadBase virtuals 68113ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn virtual void preExit(); 6829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool keepWakeLock() const { return true; } 6849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void acquireWakeLock_l() { 6859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ThreadBase::acquireWakeLock_l(); 6869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mActiveTracks.updatePowerState(this, true /* force */); 687c64edde69d18498fb2954f71a546357b07ab996aEvan Millar } 68869a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 689c64edde69d18498fb2954f71a546357b07ab996aEvan Millarpublic: 6909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 69169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } 6929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // return estimated latency in milliseconds, as reported by HAL 6949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t latency() const; 6959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // same, but lock must already be held 69669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes uint32_t latency_l() const; 6979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // VolumeInterface 6999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setMasterVolume(float value); 7009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setMasterMute(bool muted); 7019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setStreamVolume(audio_stream_type_t stream, float value); 7029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void setStreamMute(audio_stream_type_t stream, bool muted); 7039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual float streamVolume(audio_stream_type_t stream) const; 7049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project sp<Track> createTrack_l( 7069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const sp<AudioFlinger::Client>& client, 7079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_stream_type_t streamType, 7089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t *sampleRate, 7099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_format_t format, 7109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_channel_mask_t channelMask, 7119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t *pFrameCount, 7129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t *pNotificationFrameCount, 7139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t notificationsPerBuffer, 7149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project float speed, 7159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project const sp<IMemory>& sharedBuffer, 7169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId, 717c64edde69d18498fb2954f71a546357b07ab996aEvan Millar audio_output_flags_t *flags, 7189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project pid_t tid, 71969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes uid_t uid, 7209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project status_t *status /*non-NULL*/, 72169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes audio_port_handle_t portId); 7229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 72313ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn AudioStreamOut* getOutput() const; 7249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project AudioStreamOut* clearOutput(); 7259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual sp<StreamHalInterface> stream() const; 72613ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn 72713ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn // a very large number of suspend() will eventually wraparound, but unlikely 72813ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn void suspend() { (void) android_atomic_inc(&mSuspended); } 72913ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn void restore() 73013ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn { 73113ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn // if restore() is done without suspend(), get back into 7329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // range so that the next suspend() will operate correctly 7339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (android_atomic_dec(&mSuspended) <= 0) { 7349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project android_atomic_release_store(0, &mSuspended); 735c64edde69d18498fb2954f71a546357b07ab996aEvan Millar } 7369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool isSuspended() const 7389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project { return android_atomic_acquire_load(&mSuspended) > 0; } 73969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 7409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual String8 getParameters(const String8& keys); 7419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0); 742c64edde69d18498fb2954f71a546357b07ab996aEvan Millar status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); 7439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Consider also removing and passing an explicit mMainBuffer initialization 7449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // parameter to AF::PlaybackThread::Track::Track(). 7459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project effect_buffer_t *sinkBuffer() const { 7469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return reinterpret_cast<effect_buffer_t *>(mSinkBuffer); }; 74713ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn 74813ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn virtual void detachAuxEffect_l(int effectId); 74913ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track, 75013ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn int EffectId); 75113ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track, 75213ac041b9f21043bc7c848a743be618bfd7a67e9Dianne Hackborn int EffectId); 7539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 754c64edde69d18498fb2954f71a546357b07ab996aEvan Millar virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 7559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 7569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const; 7579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t getStrategyForSession_l(audio_session_t sessionId); 7589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 76069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual status_t setSyncEvent(const sp<SyncEvent>& event); 761c64edde69d18498fb2954f71a546357b07ab996aEvan Millar virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 7629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // called with AudioFlinger lock held 764c64edde69d18498fb2954f71a546357b07ab996aEvan Millar bool invalidateTracks_l(audio_stream_type_t streamType); 7659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void invalidateTracks(audio_stream_type_t streamType); 7669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual size_t frameCount() const { return mNormalFrameCount; } 7689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 76969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes status_t getTimestamp_l(AudioTimestamp& timestamp); 7706215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block 77169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes void addPatchTrack(const sp<PatchTrack>& track); 7729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void deletePatchTrack(const sp<PatchTrack>& track); 7739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void getAudioPortConfig(struct audio_port_config *config); 7759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Return the asynchronous signal wait time. 7779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; } 7789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual bool isOutput() const override { return true; } 7809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprotected: 7829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // updated by readOutputParameters_l() 7839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project size_t mNormalFrameCount; // normal mixer and effects 7849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mThreadThrottle; // throttle the thread processing 7869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads 7879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t mThreadThrottleEndMs; // notify once per throttling 7889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t mHalfBufferMs; // half the buffer size in milliseconds 7899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void* mSinkBuffer; // frame size aligned sink buffer 79169a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 7929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // TODO: 7939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Rearrange the buffer info into a struct/class with 7949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // clear, copy, construction, destruction methods. 7959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 7969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // mSinkBuffer also has associated with it: 7979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 7989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // mSinkBufferSize: Sink Buffer Size 79969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // mFormat: Sink Buffer Format 8009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Mixer Buffer (mMixerBuffer*) 8029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // 803c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // In the case of floating point or multichannel data, which is not in the 80469a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // sink format, it is required to accumulate in a higher precision or greater channel count 805c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // buffer before downmixing or data conversion to the sink buffer. 806c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 807c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer. 808c64edde69d18498fb2954f71a546357b07ab996aEvan Millar bool mMixerBufferEnabled; 80969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 81069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // Storage, 32 byte aligned (may make this alignment a requirement later). 811c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames. 81269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes void* mMixerBuffer; 813c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 81469a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize. 815c64edde69d18498fb2954f71a546357b07ab996aEvan Millar size_t mMixerBufferSize; 816c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 817c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only. 818c64edde69d18498fb2954f71a546357b07ab996aEvan Millar audio_format_t mMixerBufferFormat; 819c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 820c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // An internal flag set to true by MixerThread::prepareTracks_l() 821c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // when mMixerBuffer contains valid data after mixing. 822c64edde69d18498fb2954f71a546357b07ab996aEvan Millar bool mMixerBufferValid; 82369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 824c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Effects Buffer (mEffectsBuffer*) 825c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // 826c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // In the case of effects data, which is not in the sink format, 827c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // it is required to accumulate in a different buffer before data conversion 828c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // to the sink buffer. 829c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 830c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer. 831c64edde69d18498fb2954f71a546357b07ab996aEvan Millar bool mEffectBufferEnabled; 832c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 833c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Storage, 32 byte aligned (may make this alignment a requirement later). 83469a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames. 835c64edde69d18498fb2954f71a546357b07ab996aEvan Millar void* mEffectBuffer; 8368564c8da817a845353d213acd8636b76f567b234Steve Block 837c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize. 838c64edde69d18498fb2954f71a546357b07ab996aEvan Millar size_t mEffectBufferSize; 83969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 840c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only. 841c64edde69d18498fb2954f71a546357b07ab996aEvan Millar audio_format_t mEffectBufferFormat; 842c64edde69d18498fb2954f71a546357b07ab996aEvan Millar 84369a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // An internal flag set to true by MixerThread::prepareTracks_l() 844c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // when mEffectsBuffer contains valid data after mixing. 8458564c8da817a845353d213acd8636b76f567b234Steve Block // 846c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // When this is set, all mixer data is routed into the effects buffer 847c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // for any processing (including output processing). 848c64edde69d18498fb2954f71a546357b07ab996aEvan Millar bool mEffectBufferValid; 84969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes 85069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // suspend count, > 0 means suspended. While suspended, the thread continues to pull from 851c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle 85269a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // concurrent use of both of them, so Audio Policy Service suspends one of the threads to 853c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // workaround that restriction. 854c64edde69d18498fb2954f71a546357b07ab996aEvan Millar // 'volatile' means accessed via atomic operations and no lock. 8559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project volatile int32_t mSuspended; 8569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int64_t mBytesWritten; 8589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int64_t mFramesWritten; // not reset on standby 85969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes int64_t mSuspendedFrames; // not reset on standby 8609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprivate: 8619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // mMasterMute is in both PlaybackThread and in AudioFlinger. When a 8629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // PlaybackThread needs to find out if master-muted, it checks it's local 8639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // copy rather than the one in AudioFlinger. This optimization saves a lock. 8649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool mMasterMute; 8659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void setMasterMute_l(bool muted) { mMasterMute = muted; } 8669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprotected: 8679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project ActiveTracks<Track> mActiveTracks; 8689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8696215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block // Allocate a track name for a given channel mask. 8709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Returns name >= 0 if successful, -1 on failure. 8719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format, 8729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_session_t sessionId, uid_t uid) = 0; 8739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void deleteTrackName_l(int name) = 0; 874906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn 875906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn // Time to sleep between cycles when: 876906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED 877906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE 878906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us 879906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write() 880906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn // No sleep in standby mode; waits on a condition 8819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Code snippets that are temporarily lifted up out of threadLoop() until the merge 8839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void checkSilentMode_l(); 8849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Non-trivial for DUPLICATING only 88669a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void saveOutputTracks() { } 8879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void clearOutputTracks() { } 8889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 88969a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes // Cache various calculated values, at threadLoop() entry and after a parameter change 89069a017bc1d1649350f830dfada5c6ed5eac0b770Elliott Hughes virtual void cacheParameters_l(); 8919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t correctLatency_l(uint32_t latency) const; 8939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual status_t createAudioPatch_l(const struct audio_patch *patch, 8959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_patch_handle_t *handle); 8969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 8979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL) 8999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project && mHwSupportsPause 9009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); } 9019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project uint32_t trackCountForUid_l(uid_t uid); 9039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprivate: 9059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project friend class AudioFlinger; // for numerous 9079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project DISALLOW_COPY_AND_ASSIGN(PlaybackThread); 9099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project status_t addTrack_l(const sp<Track>& track); 9119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool destroyTrack_l(const sp<Track>& track); 9129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void removeTrack_l(const sp<Track>& track); 9139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void readOutputParameters_l(); 9159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dumpInternals(int fd, const Vector<String16>& args); 9179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project void dumpTracks(int fd, const Vector<String16>& args); 9189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SortedVector< sp<Track> > mTracks; 9209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; 9219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project AudioStreamOut *mOutput; 922f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 923f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn float mMasterVolume; 924f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn nsecs_t mLastWriteTime; 925f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn int mNumWrites; 926f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn int mNumDelayedWrites; 927f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn bool mInWrite; 928f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 929f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // FIXME rename these former local variables of threadLoop to standard "m" names 930f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn nsecs_t mStandbyTimeNs; 931f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn size_t mSinkBufferSize; 932f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 933f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l() 934f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mActiveSleepTimeUs; 935f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mIdleSleepTimeUs; 936f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 937f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mSleepTimeUs; 938f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 939f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // mixer status returned by prepareTracks_l() 940f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn mixer_state mMixerStatus; // current cycle 941f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // previous cycle when in prepareTracks_l() 942f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn mixer_state mMixerStatusIgnoringFastTracks; 943f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // FIXME or a separate ready state per track 944f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 945f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // FIXME move these declarations into the specific sub-class that needs them 946f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // MIXER only 947f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t sleepTimeShift; 948f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 949f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value 950f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn nsecs_t mStandbyDelayNs; 951f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 952f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // MIXER only 953f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn nsecs_t maxPeriod; 954f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 955f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // DUPLICATING only 956f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t writeFrames; 957f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 958f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn size_t mBytesRemaining; 959f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn size_t mCurrentWriteLength; 960f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn bool mUseAsyncWrite; 961f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is 962f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // incremented each time a write(), a flush() or a standby() occurs. 963f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // Bit 0 is set when a write blocks and indicates a callback is expected. 964f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence 965f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // callbacks are ignored. 966f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mWriteAckSequence; 967f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is 968f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // incremented each time a drain is requested or a flush() or standby() occurs. 969f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is 970f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // expected. 971f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence 972f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // callbacks are ignored. 973f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mDrainSequence; 974f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<AsyncCallbackThread> mCallbackThread; 975f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 976f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackbornprivate: 977f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // The HAL output sink is treated as non-blocking, but current implementation is blocking 978f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBAIO_Sink> mOutputSink; 979f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // If a fast mixer is present, the blocking pipe sink, otherwise clear 980f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBAIO_Sink> mPipeSink; 981f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink 982f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBAIO_Sink> mNormalSink; 983f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn#ifdef TEE_SINK 984f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // For dumpsys 985f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBAIO_Sink> mTeeSink; 986f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBAIO_Source> mTeeSource; 987f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn#endif 988f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn uint32_t mScreenState; // cached copy of gScreenState 989f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // TODO: add comment and adjust size as needed 990f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn static const size_t kFastMixerLogSize = 8 * 1024; 991f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn sp<NBLog::Writer> mFastMixerNBLogWriter; 992f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 993f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 994f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackbornpublic: 995f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn virtual bool hasFastMixer() const = 0; 996f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const 997f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn { FastTrackUnderruns dummy; return dummy; } 998f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn 999f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackbornprotected: 1000f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // accessed by both binder threads and within threadLoop(), lock on mutex needed 1001f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available 1002f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn bool mHwSupportsPause; 1003f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn bool mHwPaused; 1004f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn bool mFlushPending; 1005f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn // volumes last sent to audio HAL with stream->setVolume() 1006f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn float mLeftVolFloat; 1007f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn float mRightVolFloat; 1008f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn}; 10099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectclass MixerThread : public PlaybackThread { 101180b12fcaaec458377d966803c3a61504f0897ea1Romain Guypublic: 10129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project MixerThread(const sp<AudioFlinger>& audioFlinger, 10139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project AudioStreamOut* output, 10149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_io_handle_t id, 10159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project audio_devices_t device, 10169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project bool systemReady, 10176793ac943afeb16642f477c43ddfd27e498db37bGlenn Kasten type_t type = MIXER); 1018160edb3645f8b7012bab70ae6e6e8c4a5733082bChristopher Tate virtual ~MixerThread(); 10199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Thread virtuals 1021e9d376b801b7890b1ef5006ed55de4208e64bb63San Mehat 10229e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey virtual bool checkForNewParameter_l(const String8& keyValuePair, 10239e57c414f39e1a31349bc215635fdcfaf1902ceeJeff Sharkey status_t& status); 10249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void dumpInternals(int fd, const Vector<String16>& args); 10259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectprotected: 10279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 10289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format, 1029906497c574d45d8dfd295b16dece0d0bc32c0895Dianne Hackborn audio_session_t sessionId, uid_t uid); 10300bca96bcbfe559f9330a01f723c5c9cba51ec05aMarco Nelissen virtual void deleteTrackName_l(int name); 103159325eb31f25704bb88c348160bb69e7c1aa3b48Dianne Hackborn virtual uint32_t idleSleepTimeUs() const; 10329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t suspendSleepTimeUs() const; 10339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void cacheParameters_l(); 10349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1035c64edde69d18498fb2954f71a546357b07ab996aEvan Millar virtual void acquireWakeLock_l() { 10369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project PlaybackThread::acquireWakeLock_l(); 10379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (hasFastMixer()) { 1038f72467ad9843bf5d4b75fb308386e77ebb5c3447Dianne Hackborn mFastMixer->setBoottimeOffset( 10399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]); 10409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // threadLoop snippets 10449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual ssize_t threadLoop_write(); 10459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_standby(); 10469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_mix(); 10479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_sleepTime(); 10489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove); 10499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project virtual uint32_t correctLatency_l(uint32_t latency) const; 1050 1051 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1052 audio_patch_handle_t *handle); 1053 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1054 1055 AudioMixer* mAudioMixer; // normal mixer 1056private: 1057 // one-time initialization, no locks required 1058 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer 1059 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread 1060 1061 // contents are not guaranteed to be consistent, no locks required 1062 FastMixerDumpState mFastMixerDumpState; 1063#ifdef STATE_QUEUE_DUMP 1064 StateQueueObserverDump mStateQueueObserverDump; 1065 StateQueueMutatorDump mStateQueueMutatorDump; 1066#endif 1067 AudioWatchdogDump mAudioWatchdogDump; 1068 1069 // accessible only within the threadLoop(), no locks required 1070 // mFastMixer->sq() // for mutating and pushing state 1071 int32_t mFastMixerFutex; // for cold idle 1072 1073 std::atomic_bool mMasterMono; 1074public: 1075 virtual bool hasFastMixer() const { return mFastMixer != 0; } 1076 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const { 1077 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks); 1078 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns; 1079 } 1080 1081protected: 1082 virtual void setMasterMono_l(bool mono) { 1083 mMasterMono.store(mono); 1084 if (mFastMixer != nullptr) { /* hasFastMixer() */ 1085 mFastMixer->setMasterMono(mMasterMono); 1086 } 1087 } 1088 // the FastMixer performs mono blend if it exists. 1089 // Blending with limiter is not idempotent, 1090 // and blending without limiter is idempotent but inefficient to do twice. 1091 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); } 1092}; 1093 1094class DirectOutputThread : public PlaybackThread { 1095public: 1096 1097 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1098 audio_io_handle_t id, audio_devices_t device, bool systemReady); 1099 virtual ~DirectOutputThread(); 1100 1101 // Thread virtuals 1102 1103 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1104 status_t& status); 1105 virtual void flushHw_l(); 1106 1107protected: 1108 virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format, 1109 audio_session_t sessionId, uid_t uid); 1110 virtual void deleteTrackName_l(int name); 1111 virtual uint32_t activeSleepTimeUs() const; 1112 virtual uint32_t idleSleepTimeUs() const; 1113 virtual uint32_t suspendSleepTimeUs() const; 1114 virtual void cacheParameters_l(); 1115 1116 // threadLoop snippets 1117 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1118 virtual void threadLoop_mix(); 1119 virtual void threadLoop_sleepTime(); 1120 virtual void threadLoop_exit(); 1121 virtual bool shouldStandby_l(); 1122 1123 virtual void onAddNewTrack_l(); 1124 1125 bool mVolumeShaperActive; 1126 1127 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1128 audio_io_handle_t id, uint32_t device, ThreadBase::type_t type, 1129 bool systemReady); 1130 void processVolume_l(Track *track, bool lastTrack); 1131 1132 // prepareTracks_l() tells threadLoop_mix() the name of the single active track 1133 sp<Track> mActiveTrack; 1134 1135 wp<Track> mPreviousTrack; // used to detect track switch 1136 1137public: 1138 virtual bool hasFastMixer() const { return false; } 1139 1140 virtual int64_t computeWaitTimeNs_l() const override; 1141}; 1142 1143class OffloadThread : public DirectOutputThread { 1144public: 1145 1146 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1147 audio_io_handle_t id, uint32_t device, bool systemReady); 1148 virtual ~OffloadThread() {}; 1149 virtual void flushHw_l(); 1150 1151protected: 1152 // threadLoop snippets 1153 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1154 virtual void threadLoop_exit(); 1155 1156 virtual bool waitingAsyncCallback(); 1157 virtual bool waitingAsyncCallback_l(); 1158 virtual void invalidateTracks(audio_stream_type_t streamType); 1159 1160 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); } 1161 1162private: 1163 size_t mPausedWriteLength; // length in bytes of write interrupted by pause 1164 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume 1165 bool mKeepWakeLock; // keep wake lock while waiting for write callback 1166 uint64_t mOffloadUnderrunPosition; // Current frame position for offloaded playback 1167 // used and valid only during underrun. ~0 if 1168 // no underrun has occurred during playback and 1169 // is not reset on standby. 1170}; 1171 1172class AsyncCallbackThread : public Thread { 1173public: 1174 1175 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread); 1176 1177 virtual ~AsyncCallbackThread(); 1178 1179 // Thread virtuals 1180 virtual bool threadLoop(); 1181 1182 // RefBase 1183 virtual void onFirstRef(); 1184 1185 void exit(); 1186 void setWriteBlocked(uint32_t sequence); 1187 void resetWriteBlocked(); 1188 void setDraining(uint32_t sequence); 1189 void resetDraining(); 1190 void setAsyncError(); 1191 1192private: 1193 const wp<PlaybackThread> mPlaybackThread; 1194 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via 1195 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used 1196 // to indicate that the callback has been received via resetWriteBlocked() 1197 uint32_t mWriteAckSequence; 1198 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via 1199 // setDraining(). The sequence is shifted one bit to the left and the lsb is used 1200 // to indicate that the callback has been received via resetDraining() 1201 uint32_t mDrainSequence; 1202 Condition mWaitWorkCV; 1203 Mutex mLock; 1204 bool mAsyncError; 1205}; 1206 1207class DuplicatingThread : public MixerThread { 1208public: 1209 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, 1210 audio_io_handle_t id, bool systemReady); 1211 virtual ~DuplicatingThread(); 1212 1213 // Thread virtuals 1214 void addOutputTrack(MixerThread* thread); 1215 void removeOutputTrack(MixerThread* thread); 1216 uint32_t waitTimeMs() const { return mWaitTimeMs; } 1217protected: 1218 virtual uint32_t activeSleepTimeUs() const; 1219 1220private: 1221 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks); 1222protected: 1223 // threadLoop snippets 1224 virtual void threadLoop_mix(); 1225 virtual void threadLoop_sleepTime(); 1226 virtual ssize_t threadLoop_write(); 1227 virtual void threadLoop_standby(); 1228 virtual void cacheParameters_l(); 1229 1230private: 1231 // called from threadLoop, addOutputTrack, removeOutputTrack 1232 virtual void updateWaitTime_l(); 1233protected: 1234 virtual void saveOutputTracks(); 1235 virtual void clearOutputTracks(); 1236private: 1237 1238 uint32_t mWaitTimeMs; 1239 SortedVector < sp<OutputTrack> > outputTracks; 1240 SortedVector < sp<OutputTrack> > mOutputTracks; 1241public: 1242 virtual bool hasFastMixer() const { return false; } 1243}; 1244 1245// record thread 1246class RecordThread : public ThreadBase 1247{ 1248public: 1249 1250 class RecordTrack; 1251 1252 /* The ResamplerBufferProvider is used to retrieve recorded input data from the 1253 * RecordThread. It maintains local state on the relative position of the read 1254 * position of the RecordTrack compared with the RecordThread. 1255 */ 1256 class ResamplerBufferProvider : public AudioBufferProvider 1257 { 1258 public: 1259 explicit ResamplerBufferProvider(RecordTrack* recordTrack) : 1260 mRecordTrack(recordTrack), 1261 mRsmpInUnrel(0), mRsmpInFront(0) { } 1262 virtual ~ResamplerBufferProvider() { } 1263 1264 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer, 1265 // skipping any previous data read from the hal. 1266 virtual void reset(); 1267 1268 /* Synchronizes RecordTrack position with the RecordThread. 1269 * Calculates available frames and handle overruns if the RecordThread 1270 * has advanced faster than the ResamplerBufferProvider has retrieved data. 1271 * TODO: why not do this for every getNextBuffer? 1272 * 1273 * Parameters 1274 * framesAvailable: pointer to optional output size_t to store record track 1275 * frames available. 1276 * hasOverrun: pointer to optional boolean, returns true if track has overrun. 1277 */ 1278 1279 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL); 1280 1281 // AudioBufferProvider interface 1282 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 1283 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 1284 private: 1285 RecordTrack * const mRecordTrack; 1286 size_t mRsmpInUnrel; // unreleased frames remaining from 1287 // most recent getNextBuffer 1288 // for debug only 1289 int32_t mRsmpInFront; // next available frame 1290 // rolling counter that is never cleared 1291 }; 1292 1293#include "RecordTracks.h" 1294 1295 RecordThread(const sp<AudioFlinger>& audioFlinger, 1296 AudioStreamIn *input, 1297 audio_io_handle_t id, 1298 audio_devices_t outDevice, 1299 audio_devices_t inDevice, 1300 bool systemReady 1301#ifdef TEE_SINK 1302 , const sp<NBAIO_Sink>& teeSink 1303#endif 1304 ); 1305 virtual ~RecordThread(); 1306 1307 // no addTrack_l ? 1308 void destroyTrack_l(const sp<RecordTrack>& track); 1309 void removeTrack_l(const sp<RecordTrack>& track); 1310 1311 void dumpInternals(int fd, const Vector<String16>& args); 1312 void dumpTracks(int fd, const Vector<String16>& args); 1313 1314 // Thread virtuals 1315 virtual bool threadLoop(); 1316 virtual void preExit(); 1317 1318 // RefBase 1319 virtual void onFirstRef(); 1320 1321 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } 1322 1323 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; } 1324 1325 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; } 1326 1327 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( 1328 const sp<AudioFlinger::Client>& client, 1329 uint32_t *pSampleRate, 1330 audio_format_t format, 1331 audio_channel_mask_t channelMask, 1332 size_t *pFrameCount, 1333 audio_session_t sessionId, 1334 size_t *pNotificationFrameCount, 1335 uid_t uid, 1336 audio_input_flags_t *flags, 1337 pid_t tid, 1338 status_t *status /*non-NULL*/, 1339 audio_port_handle_t portId); 1340 1341 status_t start(RecordTrack* recordTrack, 1342 AudioSystem::sync_event_t event, 1343 audio_session_t triggerSession); 1344 1345 // ask the thread to stop the specified track, and 1346 // return true if the caller should then do it's part of the stopping process 1347 bool stop(RecordTrack* recordTrack); 1348 1349 void dump(int fd, const Vector<String16>& args); 1350 AudioStreamIn* clearInput(); 1351 virtual sp<StreamHalInterface> stream() const; 1352 1353 1354 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1355 status_t& status); 1356 virtual void cacheParameters_l() {} 1357 virtual String8 getParameters(const String8& keys); 1358 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0); 1359 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1360 audio_patch_handle_t *handle); 1361 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1362 1363 void addPatchRecord(const sp<PatchRecord>& record); 1364 void deletePatchRecord(const sp<PatchRecord>& record); 1365 1366 void readInputParameters_l(); 1367 virtual uint32_t getInputFramesLost(); 1368 1369 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 1370 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 1371 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const; 1372 1373 // Return the set of unique session IDs across all tracks. 1374 // The keys are the session IDs, and the associated values are meaningless. 1375 // FIXME replace by Set [and implement Bag/Multiset for other uses]. 1376 KeyedVector<audio_session_t, bool> sessionIds() const; 1377 1378 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 1379 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 1380 1381 static void syncStartEventCallback(const wp<SyncEvent>& event); 1382 1383 virtual size_t frameCount() const { return mFrameCount; } 1384 bool hasFastCapture() const { return mFastCapture != 0; } 1385 virtual void getAudioPortConfig(struct audio_port_config *config); 1386 1387 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 1388 audio_session_t sessionId); 1389 1390 virtual void acquireWakeLock_l() { 1391 ThreadBase::acquireWakeLock_l(); 1392 mActiveTracks.updatePowerState(this, true /* force */); 1393 } 1394 virtual bool isOutput() const override { return false; } 1395 1396 void checkBtNrec(); 1397 1398private: 1399 // Enter standby if not already in standby, and set mStandby flag 1400 void standbyIfNotAlreadyInStandby(); 1401 1402 // Call the HAL standby method unconditionally, and don't change mStandby flag 1403 void inputStandBy(); 1404 1405 void checkBtNrec_l(); 1406 1407 AudioStreamIn *mInput; 1408 SortedVector < sp<RecordTrack> > mTracks; 1409 // mActiveTracks has dual roles: it indicates the current active track(s), and 1410 // is used together with mStartStopCond to indicate start()/stop() progress 1411 ActiveTracks<RecordTrack> mActiveTracks; 1412 1413 Condition mStartStopCond; 1414 1415 // resampler converts input at HAL Hz to output at AudioRecord client Hz 1416 void *mRsmpInBuffer; // size = mRsmpInFramesOA 1417 size_t mRsmpInFrames; // size of resampler input in frames 1418 size_t mRsmpInFramesP2;// size rounded up to a power-of-2 1419 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation 1420 1421 // rolling index that is never cleared 1422 int32_t mRsmpInRear; // last filled frame + 1 1423 1424 // For dumpsys 1425 const sp<NBAIO_Sink> mTeeSink; 1426 1427 const sp<MemoryDealer> mReadOnlyHeap; 1428 1429 // one-time initialization, no locks required 1430 sp<FastCapture> mFastCapture; // non-0 if there is also 1431 // a fast capture 1432 1433 // FIXME audio watchdog thread 1434 1435 // contents are not guaranteed to be consistent, no locks required 1436 FastCaptureDumpState mFastCaptureDumpState; 1437#ifdef STATE_QUEUE_DUMP 1438 // FIXME StateQueue observer and mutator dump fields 1439#endif 1440 // FIXME audio watchdog dump 1441 1442 // accessible only within the threadLoop(), no locks required 1443 // mFastCapture->sq() // for mutating and pushing state 1444 int32_t mFastCaptureFutex; // for cold idle 1445 1446 // The HAL input source is treated as non-blocking, 1447 // but current implementation is blocking 1448 sp<NBAIO_Source> mInputSource; 1449 // The source for the normal capture thread to read from: mInputSource or mPipeSource 1450 sp<NBAIO_Source> mNormalSource; 1451 // If a fast capture is present, the non-blocking pipe sink written to by fast capture, 1452 // otherwise clear 1453 sp<NBAIO_Sink> mPipeSink; 1454 // If a fast capture is present, the non-blocking pipe source read by normal thread, 1455 // otherwise clear 1456 sp<NBAIO_Source> mPipeSource; 1457 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2 1458 size_t mPipeFramesP2; 1459 // If a fast capture is present, the Pipe as IMemory, otherwise clear 1460 sp<IMemory> mPipeMemory; 1461 1462 // TODO: add comment and adjust size as needed 1463 static const size_t kFastCaptureLogSize = 4 * 1024; 1464 sp<NBLog::Writer> mFastCaptureNBLogWriter; 1465 1466 bool mFastTrackAvail; // true if fast track available 1467 // common state to all record threads 1468 std::atomic_bool mBtNrecSuspended; 1469}; 1470 1471class MmapThread : public ThreadBase 1472{ 1473 public: 1474 1475#include "MmapTracks.h" 1476 1477 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 1478 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, 1479 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady); 1480 virtual ~MmapThread(); 1481 1482 virtual void configure(const audio_attributes_t *attr, 1483 audio_stream_type_t streamType, 1484 audio_session_t sessionId, 1485 const sp<MmapStreamCallback>& callback, 1486 audio_port_handle_t deviceId, 1487 audio_port_handle_t portId); 1488 1489 void disconnect(); 1490 1491 // MmapStreamInterface 1492 status_t createMmapBuffer(int32_t minSizeFrames, 1493 struct audio_mmap_buffer_info *info); 1494 status_t getMmapPosition(struct audio_mmap_position *position); 1495 status_t start(const AudioClient& client, audio_port_handle_t *handle); 1496 status_t stop(audio_port_handle_t handle); 1497 status_t standby(); 1498 1499 // RefBase 1500 virtual void onFirstRef(); 1501 1502 // Thread virtuals 1503 virtual bool threadLoop(); 1504 1505 virtual void threadLoop_exit(); 1506 virtual void threadLoop_standby(); 1507 virtual bool shouldStandby_l() { return false; } 1508 1509 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; } 1510 virtual size_t frameCount() const { return mFrameCount; } 1511 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1512 status_t& status); 1513 virtual String8 getParameters(const String8& keys); 1514 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0); 1515 void readHalParameters_l(); 1516 virtual void cacheParameters_l() {} 1517 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1518 audio_patch_handle_t *handle); 1519 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1520 virtual void getAudioPortConfig(struct audio_port_config *config); 1521 1522 virtual sp<StreamHalInterface> stream() const { return mHalStream; } 1523 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 1524 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 1525 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 1526 audio_session_t sessionId); 1527 1528 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const; 1529 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 1530 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 1531 1532 virtual void checkSilentMode_l() {} 1533 virtual void processVolume_l() {} 1534 void checkInvalidTracks_l(); 1535 1536 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; } 1537 1538 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {} 1539 1540 void dump(int fd, const Vector<String16>& args); 1541 virtual void dumpInternals(int fd, const Vector<String16>& args); 1542 void dumpTracks(int fd, const Vector<String16>& args); 1543 1544 protected: 1545 1546 audio_attributes_t mAttr; 1547 audio_session_t mSessionId; 1548 audio_port_handle_t mDeviceId; 1549 audio_port_handle_t mPortId; 1550 1551 wp<MmapStreamCallback> mCallback; 1552 sp<StreamHalInterface> mHalStream; 1553 sp<DeviceHalInterface> mHalDevice; 1554 AudioHwDevice* const mAudioHwDev; 1555 ActiveTracks<MmapTrack> mActiveTracks; 1556}; 1557 1558class MmapPlaybackThread : public MmapThread, public VolumeInterface 1559{ 1560 1561public: 1562 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 1563 AudioHwDevice *hwDev, AudioStreamOut *output, 1564 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady); 1565 virtual ~MmapPlaybackThread() {} 1566 1567 virtual void configure(const audio_attributes_t *attr, 1568 audio_stream_type_t streamType, 1569 audio_session_t sessionId, 1570 const sp<MmapStreamCallback>& callback, 1571 audio_port_handle_t deviceId, 1572 audio_port_handle_t portId); 1573 1574 AudioStreamOut* clearOutput(); 1575 1576 // VolumeInterface 1577 virtual void setMasterVolume(float value); 1578 virtual void setMasterMute(bool muted); 1579 virtual void setStreamVolume(audio_stream_type_t stream, float value); 1580 virtual void setStreamMute(audio_stream_type_t stream, bool muted); 1581 virtual float streamVolume(audio_stream_type_t stream) const; 1582 1583 void setMasterMute_l(bool muted) { mMasterMute = muted; } 1584 1585 virtual void invalidateTracks(audio_stream_type_t streamType); 1586 1587 virtual audio_stream_type_t streamType() { return mStreamType; } 1588 virtual void checkSilentMode_l(); 1589 virtual void processVolume_l(); 1590 1591 virtual void dumpInternals(int fd, const Vector<String16>& args); 1592 1593 virtual bool isOutput() const override { return true; } 1594 1595protected: 1596 1597 audio_stream_type_t mStreamType; 1598 float mMasterVolume; 1599 float mStreamVolume; 1600 bool mMasterMute; 1601 bool mStreamMute; 1602 float mHalVolFloat; 1603 AudioStreamOut* mOutput; 1604}; 1605 1606class MmapCaptureThread : public MmapThread 1607{ 1608 1609public: 1610 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 1611 AudioHwDevice *hwDev, AudioStreamIn *input, 1612 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady); 1613 virtual ~MmapCaptureThread() {} 1614 1615 AudioStreamIn* clearInput(); 1616 1617 virtual bool isOutput() const override { return false; } 1618 1619protected: 1620 1621 AudioStreamIn* mInput; 1622}; 1623