Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1 | /* |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 2 | ** |
| 3 | ** Copyright 2007, The Android Open Source Project |
| 4 | ** |
| 5 | ** Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | ** you may not use this file except in compliance with the License. |
| 7 | ** You may obtain a copy of the License at |
| 8 | ** |
| 9 | ** http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | ** |
| 11 | ** Unless required by applicable law or agreed to in writing, software |
| 12 | ** distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | ** See the License for the specific language governing permissions and |
| 15 | ** limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | #ifndef ANDROID_AUDIO_FLINGER_H |
| 19 | #define ANDROID_AUDIO_FLINGER_H |
| 20 | |
| 21 | #include <stdint.h> |
| 22 | #include <sys/types.h> |
| 23 | #include <limits.h> |
| 24 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 25 | #include <common_time/cc_helper.h> |
| 26 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 27 | #include <media/IAudioFlinger.h> |
| 28 | #include <media/IAudioFlingerClient.h> |
| 29 | #include <media/IAudioTrack.h> |
| 30 | #include <media/IAudioRecord.h> |
Glenn Kasten | 335787f | 2012-01-20 17:00:00 -0800 | [diff] [blame] | 31 | #include <media/AudioSystem.h> |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 32 | #include <media/AudioTrack.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 33 | |
| 34 | #include <utils/Atomic.h> |
| 35 | #include <utils/Errors.h> |
| 36 | #include <utils/threads.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 37 | #include <utils/SortedVector.h> |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 38 | #include <utils/TypeHelpers.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 39 | #include <utils/Vector.h> |
| 40 | |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 41 | #include <binder/BinderService.h> |
| 42 | #include <binder/MemoryDealer.h> |
| 43 | |
Dima Zavin | 6476024 | 2011-05-11 14:15:23 -0700 | [diff] [blame] | 44 | #include <system/audio.h> |
Dima Zavin | 7394a4f | 2011-06-13 18:16:26 -0700 | [diff] [blame] | 45 | #include <hardware/audio.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 46 | |
| 47 | #include "AudioBufferProvider.h" |
| 48 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 49 | #include <powermanager/IPowerManager.h> |
| 50 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 51 | namespace android { |
| 52 | |
| 53 | class audio_track_cblk_t; |
| 54 | class effect_param_cblk_t; |
| 55 | class AudioMixer; |
| 56 | class AudioBuffer; |
| 57 | class AudioResampler; |
| 58 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 59 | // ---------------------------------------------------------------------------- |
| 60 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 61 | static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 62 | |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 63 | class AudioFlinger : |
| 64 | public BinderService<AudioFlinger>, |
| 65 | public BnAudioFlinger |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 66 | { |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 67 | friend class BinderService<AudioFlinger>; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 68 | public: |
Glenn Kasten | 54c3b66 | 2012-01-06 07:46:30 -0800 | [diff] [blame] | 69 | static const char* getServiceName() { return "media.audio_flinger"; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 70 | |
| 71 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 72 | |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 73 | // IAudioFlinger interface, in binder opcode order |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 74 | virtual sp<IAudioTrack> createTrack( |
| 75 | pid_t pid, |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 76 | audio_stream_type_t streamType, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 77 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 78 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 79 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 80 | int frameCount, |
| 81 | uint32_t flags, |
| 82 | const sp<IMemory>& sharedBuffer, |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 83 | audio_io_handle_t output, |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 84 | bool isTimed, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 85 | int *sessionId, |
| 86 | status_t *status); |
| 87 | |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 88 | virtual sp<IAudioRecord> openRecord( |
| 89 | pid_t pid, |
| 90 | audio_io_handle_t input, |
| 91 | uint32_t sampleRate, |
| 92 | audio_format_t format, |
| 93 | uint32_t channelMask, |
| 94 | int frameCount, |
| 95 | uint32_t flags, |
| 96 | int *sessionId, |
| 97 | status_t *status); |
| 98 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 99 | virtual uint32_t sampleRate(audio_io_handle_t output) const; |
| 100 | virtual int channelCount(audio_io_handle_t output) const; |
| 101 | virtual audio_format_t format(audio_io_handle_t output) const; |
| 102 | virtual size_t frameCount(audio_io_handle_t output) const; |
| 103 | virtual uint32_t latency(audio_io_handle_t output) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 104 | |
| 105 | virtual status_t setMasterVolume(float value); |
| 106 | virtual status_t setMasterMute(bool muted); |
| 107 | |
| 108 | virtual float masterVolume() const; |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 109 | virtual float masterVolumeSW() const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 110 | virtual bool masterMute() const; |
| 111 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 112 | virtual status_t setStreamVolume(audio_stream_type_t stream, float value, |
| 113 | audio_io_handle_t output); |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 114 | virtual status_t setStreamMute(audio_stream_type_t stream, bool muted); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 115 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 116 | virtual float streamVolume(audio_stream_type_t stream, |
| 117 | audio_io_handle_t output) const; |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 118 | virtual bool streamMute(audio_stream_type_t stream) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 119 | |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 120 | virtual status_t setMode(audio_mode_t mode); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 121 | |
| 122 | virtual status_t setMicMute(bool state); |
| 123 | virtual bool getMicMute() const; |
| 124 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 125 | virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); |
| 126 | virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 127 | |
| 128 | virtual void registerClient(const sp<IAudioFlingerClient>& client); |
| 129 | |
Glenn Kasten | f587ba5 | 2012-01-26 16:25:10 -0800 | [diff] [blame] | 130 | virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 131 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 132 | virtual audio_io_handle_t openOutput(uint32_t *pDevices, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 133 | uint32_t *pSamplingRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 134 | audio_format_t *pFormat, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 135 | uint32_t *pChannels, |
| 136 | uint32_t *pLatencyMs, |
| 137 | uint32_t flags); |
| 138 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 139 | virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, |
| 140 | audio_io_handle_t output2); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 141 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 142 | virtual status_t closeOutput(audio_io_handle_t output); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 143 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 144 | virtual status_t suspendOutput(audio_io_handle_t output); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 145 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 146 | virtual status_t restoreOutput(audio_io_handle_t output); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 147 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 148 | virtual audio_io_handle_t openInput(uint32_t *pDevices, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 149 | uint32_t *pSamplingRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 150 | audio_format_t *pFormat, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 151 | uint32_t *pChannels, |
Glenn Kasten | de9719b | 2012-01-27 12:32:34 -0800 | [diff] [blame] | 152 | audio_in_acoustics_t acoustics); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 153 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 154 | virtual status_t closeInput(audio_io_handle_t input); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 155 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 156 | virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 157 | |
| 158 | virtual status_t setVoiceVolume(float volume); |
| 159 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 160 | virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, |
| 161 | audio_io_handle_t output) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 162 | |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 163 | virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const; |
| 164 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 165 | virtual int newAudioSessionId(); |
| 166 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 167 | virtual void acquireAudioSessionId(int audioSession); |
| 168 | |
| 169 | virtual void releaseAudioSessionId(int audioSession); |
| 170 | |
Glenn Kasten | f587ba5 | 2012-01-26 16:25:10 -0800 | [diff] [blame] | 171 | virtual status_t queryNumberEffects(uint32_t *numEffects) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 172 | |
Glenn Kasten | f587ba5 | 2012-01-26 16:25:10 -0800 | [diff] [blame] | 173 | virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 174 | |
Glenn Kasten | 5e92a78 | 2012-01-30 07:40:52 -0800 | [diff] [blame] | 175 | virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, |
Glenn Kasten | f587ba5 | 2012-01-26 16:25:10 -0800 | [diff] [blame] | 176 | effect_descriptor_t *descriptor) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 177 | |
| 178 | virtual sp<IEffect> createEffect(pid_t pid, |
| 179 | effect_descriptor_t *pDesc, |
| 180 | const sp<IEffectClient>& effectClient, |
| 181 | int32_t priority, |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 182 | audio_io_handle_t io, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 183 | int sessionId, |
| 184 | status_t *status, |
| 185 | int *id, |
| 186 | int *enabled); |
| 187 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 188 | virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput, |
| 189 | audio_io_handle_t dstOutput); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 190 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 191 | virtual status_t onTransact( |
| 192 | uint32_t code, |
| 193 | const Parcel& data, |
| 194 | Parcel* reply, |
| 195 | uint32_t flags); |
| 196 | |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 197 | // end of IAudioFlinger interface |
| 198 | |
| 199 | private: |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 200 | audio_mode_t getMode() const { return mMode; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 201 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 202 | bool btNrecIsOff() const { return mBtNrecIsOff; } |
Eric Laurent | 59bd0da | 2011-08-01 09:52:20 -0700 | [diff] [blame] | 203 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 204 | AudioFlinger(); |
| 205 | virtual ~AudioFlinger(); |
| 206 | |
Glenn Kasten | 2b213bc | 2012-02-02 14:05:20 -0800 | [diff] [blame] | 207 | // call in any IAudioFlinger method that accesses mPrimaryHardwareDev |
| 208 | status_t initCheck() const { return mPrimaryHardwareDev == NULL ? NO_INIT : NO_ERROR; } |
| 209 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 210 | // RefBase |
Dima Zavin | 5a61d2f | 2011-04-19 19:04:32 -0700 | [diff] [blame] | 211 | virtual void onFirstRef(); |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 212 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 213 | audio_hw_device_t* findSuitableHwDev_l(uint32_t devices); |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 214 | void purgeStaleEffects_l(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 215 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 216 | static nsecs_t mStandbyTimeInNsecs; |
| 217 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 218 | // Internal dump utilites. |
| 219 | status_t dumpPermissionDenial(int fd, const Vector<String16>& args); |
| 220 | status_t dumpClients(int fd, const Vector<String16>& args); |
| 221 | status_t dumpInternals(int fd, const Vector<String16>& args); |
| 222 | |
| 223 | // --- Client --- |
| 224 | class Client : public RefBase { |
| 225 | public: |
| 226 | Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); |
| 227 | virtual ~Client(); |
Glenn Kasten | 435dbe6 | 2012-01-30 10:15:48 -0800 | [diff] [blame] | 228 | sp<MemoryDealer> heap() const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 229 | pid_t pid() const { return mPid; } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 230 | sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 231 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 232 | bool reserveTimedTrack(); |
| 233 | void releaseTimedTrack(); |
| 234 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 235 | private: |
| 236 | Client(const Client&); |
| 237 | Client& operator = (const Client&); |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 238 | const sp<AudioFlinger> mAudioFlinger; |
| 239 | const sp<MemoryDealer> mMemoryDealer; |
| 240 | const pid_t mPid; |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 241 | |
| 242 | Mutex mTimedTrackLock; |
| 243 | int mTimedTrackCount; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 244 | }; |
| 245 | |
| 246 | // --- Notification Client --- |
| 247 | class NotificationClient : public IBinder::DeathRecipient { |
| 248 | public: |
| 249 | NotificationClient(const sp<AudioFlinger>& audioFlinger, |
| 250 | const sp<IAudioFlingerClient>& client, |
| 251 | pid_t pid); |
| 252 | virtual ~NotificationClient(); |
| 253 | |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 254 | sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 255 | |
| 256 | // IBinder::DeathRecipient |
| 257 | virtual void binderDied(const wp<IBinder>& who); |
| 258 | |
| 259 | private: |
| 260 | NotificationClient(const NotificationClient&); |
| 261 | NotificationClient& operator = (const NotificationClient&); |
| 262 | |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 263 | const sp<AudioFlinger> mAudioFlinger; |
| 264 | const pid_t mPid; |
| 265 | const sp<IAudioFlingerClient> mAudioFlingerClient; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 266 | }; |
| 267 | |
| 268 | class TrackHandle; |
| 269 | class RecordHandle; |
| 270 | class RecordThread; |
| 271 | class PlaybackThread; |
| 272 | class MixerThread; |
| 273 | class DirectOutputThread; |
| 274 | class DuplicatingThread; |
| 275 | class Track; |
| 276 | class RecordTrack; |
| 277 | class EffectModule; |
| 278 | class EffectHandle; |
| 279 | class EffectChain; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 280 | struct AudioStreamOut; |
| 281 | struct AudioStreamIn; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 282 | |
| 283 | class ThreadBase : public Thread { |
| 284 | public: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 285 | |
Glenn Kasten | 23bb8be | 2012-01-26 10:38:26 -0800 | [diff] [blame] | 286 | enum type_t { |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 287 | MIXER, // Thread class is MixerThread |
| 288 | DIRECT, // Thread class is DirectOutputThread |
| 289 | DUPLICATING, // Thread class is DuplicatingThread |
| 290 | RECORD // Thread class is RecordThread |
| 291 | }; |
| 292 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 293 | ThreadBase (const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, uint32_t device, type_t type); |
Glenn Kasten | 23bb8be | 2012-01-26 10:38:26 -0800 | [diff] [blame] | 294 | virtual ~ThreadBase(); |
| 295 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 296 | status_t dumpBase(int fd, const Vector<String16>& args); |
Eric Laurent | 1d2bff0 | 2011-07-24 17:49:51 -0700 | [diff] [blame] | 297 | status_t dumpEffectChains(int fd, const Vector<String16>& args); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 298 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 299 | void clearPowerManager(); |
| 300 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 301 | // base for record and playback |
| 302 | class TrackBase : public AudioBufferProvider, public RefBase { |
| 303 | |
| 304 | public: |
| 305 | enum track_state { |
| 306 | IDLE, |
| 307 | TERMINATED, |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 308 | // These are order-sensitive; do not change order without reviewing the impact. |
| 309 | // In particular there are assumptions about > STOPPED. |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 310 | STOPPED, |
| 311 | RESUMING, |
| 312 | ACTIVE, |
| 313 | PAUSING, |
| 314 | PAUSED |
| 315 | }; |
| 316 | |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 317 | TrackBase(ThreadBase *thread, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 318 | const sp<Client>& client, |
| 319 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 320 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 321 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 322 | int frameCount, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 323 | const sp<IMemory>& sharedBuffer, |
| 324 | int sessionId); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 325 | virtual ~TrackBase(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 326 | |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 327 | virtual status_t start(pid_t tid) = 0; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 328 | virtual void stop() = 0; |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 329 | sp<IMemory> getCblk() const { return mCblkMemory; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 330 | audio_track_cblk_t* cblk() const { return mCblk; } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 331 | int sessionId() const { return mSessionId; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 332 | |
| 333 | protected: |
| 334 | friend class ThreadBase; |
| 335 | friend class RecordHandle; |
| 336 | friend class PlaybackThread; |
| 337 | friend class RecordThread; |
| 338 | friend class MixerThread; |
| 339 | friend class DirectOutputThread; |
| 340 | |
| 341 | TrackBase(const TrackBase&); |
| 342 | TrackBase& operator = (const TrackBase&); |
| 343 | |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 344 | // AudioBufferProvider interface |
| 345 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 346 | virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); |
| 347 | |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 348 | audio_format_t format() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 349 | return mFormat; |
| 350 | } |
| 351 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 352 | int channelCount() const { return mChannelCount; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 353 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 354 | uint32_t channelMask() const { return mChannelMask; } |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 355 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 356 | int sampleRate() const; // FIXME inline after cblk sr moved |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 357 | |
| 358 | void* getBuffer(uint32_t offset, uint32_t frames) const; |
| 359 | |
| 360 | bool isStopped() const { |
| 361 | return mState == STOPPED; |
| 362 | } |
| 363 | |
| 364 | bool isTerminated() const { |
| 365 | return mState == TERMINATED; |
| 366 | } |
| 367 | |
| 368 | bool step(); |
| 369 | void reset(); |
| 370 | |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 371 | const wp<ThreadBase> mThread; |
| 372 | /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 373 | sp<IMemory> mCblkMemory; |
| 374 | audio_track_cblk_t* mCblk; |
| 375 | void* mBuffer; |
| 376 | void* mBufferEnd; |
| 377 | uint32_t mFrameCount; |
| 378 | // we don't really need a lock for these |
Glenn Kasten | b853e98 | 2012-01-26 13:39:18 -0800 | [diff] [blame] | 379 | track_state mState; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 380 | const audio_format_t mFormat; |
Glenn Kasten | 5cf034d | 2012-02-21 10:35:56 -0800 | [diff] [blame] | 381 | bool mStepServerFailed; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 382 | const int mSessionId; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 383 | uint8_t mChannelCount; |
| 384 | uint32_t mChannelMask; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 385 | }; |
| 386 | |
| 387 | class ConfigEvent { |
| 388 | public: |
| 389 | ConfigEvent() : mEvent(0), mParam(0) {} |
| 390 | |
| 391 | int mEvent; |
| 392 | int mParam; |
| 393 | }; |
| 394 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 395 | class PMDeathRecipient : public IBinder::DeathRecipient { |
| 396 | public: |
| 397 | PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} |
| 398 | virtual ~PMDeathRecipient() {} |
| 399 | |
| 400 | // IBinder::DeathRecipient |
| 401 | virtual void binderDied(const wp<IBinder>& who); |
| 402 | |
| 403 | private: |
| 404 | PMDeathRecipient(const PMDeathRecipient&); |
| 405 | PMDeathRecipient& operator = (const PMDeathRecipient&); |
| 406 | |
| 407 | wp<ThreadBase> mThread; |
| 408 | }; |
| 409 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 410 | virtual status_t initCheck() const = 0; |
Glenn Kasten | 23bb8be | 2012-01-26 10:38:26 -0800 | [diff] [blame] | 411 | type_t type() const { return mType; } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 412 | uint32_t sampleRate() const { return mSampleRate; } |
| 413 | int channelCount() const { return mChannelCount; } |
| 414 | audio_format_t format() const { return mFormat; } |
| 415 | size_t frameCount() const { return mFrameCount; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 416 | void wakeUp() { mWaitWorkCV.broadcast(); } |
Glenn Kasten | b28686f | 2012-01-06 08:39:38 -0800 | [diff] [blame] | 417 | // Should be "virtual status_t requestExitAndWait()" and override same |
| 418 | // method in Thread, but Thread::requestExitAndWait() is not yet virtual. |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 419 | void exit(); |
| 420 | virtual bool checkForNewParameters_l() = 0; |
| 421 | virtual status_t setParameters(const String8& keyValuePairs); |
| 422 | virtual String8 getParameters(const String8& keys) = 0; |
| 423 | virtual void audioConfigChanged_l(int event, int param = 0) = 0; |
| 424 | void sendConfigEvent(int event, int param = 0); |
| 425 | void sendConfigEvent_l(int event, int param = 0); |
| 426 | void processConfigEvents(); |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 427 | audio_io_handle_t id() const { return mId;} |
Glenn Kasten | 02fe1bf | 2012-02-24 15:42:17 -0800 | [diff] [blame] | 428 | bool standby() const { return mStandby; } |
| 429 | uint32_t device() const { return mDevice; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 430 | virtual audio_stream_t* stream() = 0; |
| 431 | |
| 432 | sp<EffectHandle> createEffect_l( |
| 433 | const sp<AudioFlinger::Client>& client, |
| 434 | const sp<IEffectClient>& effectClient, |
| 435 | int32_t priority, |
| 436 | int sessionId, |
| 437 | effect_descriptor_t *desc, |
| 438 | int *enabled, |
| 439 | status_t *status); |
| 440 | void disconnectEffect(const sp< EffectModule>& effect, |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 441 | const wp<EffectHandle>& handle, |
Glenn Kasten | 58123c3 | 2012-02-03 10:32:24 -0800 | [diff] [blame] | 442 | bool unpinIfLast); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 443 | |
| 444 | // return values for hasAudioSession (bit field) |
| 445 | enum effect_state { |
| 446 | EFFECT_SESSION = 0x1, // the audio session corresponds to at least one |
| 447 | // effect |
| 448 | TRACK_SESSION = 0x2 // the audio session corresponds to at least one |
| 449 | // track |
| 450 | }; |
| 451 | |
| 452 | // get effect chain corresponding to session Id. |
| 453 | sp<EffectChain> getEffectChain(int sessionId); |
| 454 | // same as getEffectChain() but must be called with ThreadBase mutex locked |
| 455 | sp<EffectChain> getEffectChain_l(int sessionId); |
| 456 | // add an effect chain to the chain list (mEffectChains) |
| 457 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; |
| 458 | // remove an effect chain from the chain list (mEffectChains) |
| 459 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; |
Glenn Kasten | d805b71 | 2012-02-24 15:42:48 -0800 | [diff] [blame] | 460 | // lock all effect chains Mutexes. Must be called before releasing the |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 461 | // ThreadBase mutex before processing the mixer and effects. This guarantees the |
| 462 | // integrity of the chains during the process. |
Glenn Kasten | d805b71 | 2012-02-24 15:42:48 -0800 | [diff] [blame] | 463 | // Also sets the parameter 'effectChains' to current value of mEffectChains. |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 464 | void lockEffectChains_l(Vector<sp <EffectChain> >& effectChains); |
| 465 | // unlock effect chains after process |
Glenn Kasten | 02fe1bf | 2012-02-24 15:42:17 -0800 | [diff] [blame] | 466 | void unlockEffectChains(const Vector<sp<EffectChain> >& effectChains); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 467 | // set audio mode to all effect chains |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 468 | void setMode(audio_mode_t mode); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 469 | // get effect module with corresponding ID on specified audio session |
| 470 | sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId); |
| 471 | // add and effect module. Also creates the effect chain is none exists for |
| 472 | // the effects audio session |
| 473 | status_t addEffect_l(const sp< EffectModule>& effect); |
| 474 | // remove and effect module. Also removes the effect chain is this was the last |
| 475 | // effect |
| 476 | void removeEffect_l(const sp< EffectModule>& effect); |
| 477 | // detach all tracks connected to an auxiliary effect |
| 478 | virtual void detachAuxEffect_l(int effectId) {} |
| 479 | // returns either EFFECT_SESSION if effects on this audio session exist in one |
| 480 | // chain, or TRACK_SESSION if tracks on this audio session exist, or both |
| 481 | virtual uint32_t hasAudioSession(int sessionId) = 0; |
| 482 | // the value returned by default implementation is not important as the |
| 483 | // strategy is only meaningful for PlaybackThread which implements this method |
| 484 | virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 485 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 486 | // suspend or restore effect according to the type of effect passed. a NULL |
| 487 | // type pointer means suspend all effects in the session |
| 488 | void setEffectSuspended(const effect_uuid_t *type, |
| 489 | bool suspend, |
| 490 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
| 491 | // check if some effects must be suspended/restored when an effect is enabled |
| 492 | // or disabled |
Eric Laurent | a85a74a | 2011-10-19 11:44:54 -0700 | [diff] [blame] | 493 | void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 494 | bool enabled, |
| 495 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
Eric Laurent | a85a74a | 2011-10-19 11:44:54 -0700 | [diff] [blame] | 496 | void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, |
| 497 | bool enabled, |
| 498 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 499 | mutable Mutex mLock; |
| 500 | |
| 501 | protected: |
| 502 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 503 | // entry describing an effect being suspended in mSuspendedSessions keyed vector |
| 504 | class SuspendedSessionDesc : public RefBase { |
| 505 | public: |
| 506 | SuspendedSessionDesc() : mRefCount(0) {} |
| 507 | |
| 508 | int mRefCount; // number of active suspend requests |
| 509 | effect_uuid_t mType; // effect type UUID |
| 510 | }; |
| 511 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 512 | void acquireWakeLock(); |
| 513 | void acquireWakeLock_l(); |
| 514 | void releaseWakeLock(); |
| 515 | void releaseWakeLock_l(); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 516 | void setEffectSuspended_l(const effect_uuid_t *type, |
| 517 | bool suspend, |
| 518 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
| 519 | // updated mSuspendedSessions when an effect suspended or restored |
| 520 | void updateSuspendedSessions_l(const effect_uuid_t *type, |
| 521 | bool suspend, |
| 522 | int sessionId); |
| 523 | // check if some effects must be suspended when an effect chain is added |
| 524 | void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 525 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 526 | friend class AudioFlinger; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 527 | friend class Track; |
| 528 | friend class TrackBase; |
| 529 | friend class PlaybackThread; |
| 530 | friend class MixerThread; |
| 531 | friend class DirectOutputThread; |
| 532 | friend class DuplicatingThread; |
| 533 | friend class RecordThread; |
| 534 | friend class RecordTrack; |
| 535 | |
Glenn Kasten | 23bb8be | 2012-01-26 10:38:26 -0800 | [diff] [blame] | 536 | const type_t mType; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 537 | Condition mWaitWorkCV; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 538 | const sp<AudioFlinger> mAudioFlinger; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 539 | uint32_t mSampleRate; |
| 540 | size_t mFrameCount; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 541 | uint32_t mChannelMask; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 542 | uint16_t mChannelCount; |
Glenn Kasten | b998065 | 2012-01-11 09:48:27 -0800 | [diff] [blame] | 543 | size_t mFrameSize; |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 544 | audio_format_t mFormat; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 545 | Condition mParamCond; |
| 546 | Vector<String8> mNewParameters; |
| 547 | status_t mParamStatus; |
Glenn Kasten | f3990f2 | 2011-12-13 11:50:00 -0800 | [diff] [blame] | 548 | Vector<ConfigEvent> mConfigEvents; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 549 | bool mStandby; |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 550 | const audio_io_handle_t mId; |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 551 | Vector< sp<EffectChain> > mEffectChains; |
| 552 | uint32_t mDevice; // output device for PlaybackThread |
| 553 | // input + output devices for RecordThread |
Glenn Kasten | 480b468 | 2012-02-28 12:30:08 -0800 | [diff] [blame] | 554 | static const int kNameLength = 16; // prctl(PR_SET_NAME) limit |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 555 | char mName[kNameLength]; |
| 556 | sp<IPowerManager> mPowerManager; |
| 557 | sp<IBinder> mWakeLockToken; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 558 | const sp<PMDeathRecipient> mDeathRecipient; |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 559 | // list of suspended effects per session and per type. The first vector is |
| 560 | // keyed by session ID, the second by type UUID timeLow field |
| 561 | KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 562 | }; |
| 563 | |
Glenn Kasten | b7bf796 | 2012-02-08 12:36:25 -0800 | [diff] [blame] | 564 | struct stream_type_t { |
| 565 | stream_type_t() |
| 566 | : volume(1.0f), |
| 567 | mute(false), |
| 568 | valid(true) |
| 569 | { |
| 570 | } |
| 571 | float volume; |
| 572 | bool mute; |
| 573 | bool valid; |
| 574 | }; |
| 575 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 576 | // --- PlaybackThread --- |
| 577 | class PlaybackThread : public ThreadBase { |
| 578 | public: |
| 579 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 580 | enum mixer_state { |
Glenn Kasten | d805b71 | 2012-02-24 15:42:48 -0800 | [diff] [blame] | 581 | MIXER_IDLE, // no active tracks |
| 582 | MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready |
| 583 | MIXER_TRACKS_READY // at least one active track, and at least one track has data |
| 584 | // standby mode does not have an enum value |
| 585 | // suspend by audio policy manager is orthogonal to mixer state |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 586 | #if 1 |
| 587 | // FIXME remove these hacks for threadLoop_prepareTracks_l |
| 588 | , MIXER_CONTINUE // "continue;" |
| 589 | #endif |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 590 | }; |
| 591 | |
| 592 | // playback track |
| 593 | class Track : public TrackBase { |
| 594 | public: |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 595 | Track( PlaybackThread *thread, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 596 | const sp<Client>& client, |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 597 | audio_stream_type_t streamType, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 598 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 599 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 600 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 601 | int frameCount, |
| 602 | const sp<IMemory>& sharedBuffer, |
| 603 | int sessionId); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 604 | virtual ~Track(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 605 | |
| 606 | void dump(char* buffer, size_t size); |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 607 | virtual status_t start(pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 608 | virtual void stop(); |
| 609 | void pause(); |
| 610 | |
| 611 | void flush(); |
| 612 | void destroy(); |
| 613 | void mute(bool); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 614 | int name() const { |
| 615 | return mName; |
| 616 | } |
| 617 | |
Glenn Kasten | 02bbd20 | 2012-02-08 12:35:35 -0800 | [diff] [blame] | 618 | audio_stream_type_t streamType() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 619 | return mStreamType; |
| 620 | } |
| 621 | status_t attachAuxEffect(int EffectId); |
| 622 | void setAuxBuffer(int EffectId, int32_t *buffer); |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 623 | int32_t *auxBuffer() const { return mAuxBuffer; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 624 | void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 625 | int16_t *mainBuffer() const { return mMainBuffer; } |
| 626 | int auxEffectId() const { return mAuxEffectId; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 627 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 628 | protected: |
| 629 | friend class ThreadBase; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 630 | friend class TrackHandle; |
| 631 | friend class PlaybackThread; |
| 632 | friend class MixerThread; |
| 633 | friend class DirectOutputThread; |
| 634 | |
| 635 | Track(const Track&); |
| 636 | Track& operator = (const Track&); |
| 637 | |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 638 | // AudioBufferProvider interface |
| 639 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS); |
| 640 | // releaseBuffer() not overridden |
| 641 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 642 | virtual uint32_t framesReady() const; |
| 643 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 644 | bool isMuted() const { return mMute; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 645 | bool isPausing() const { |
| 646 | return mState == PAUSING; |
| 647 | } |
| 648 | bool isPaused() const { |
| 649 | return mState == PAUSED; |
| 650 | } |
| 651 | bool isReady() const; |
| 652 | void setPaused() { mState = PAUSED; } |
| 653 | void reset(); |
| 654 | |
| 655 | bool isOutputTrack() const { |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 656 | return (mStreamType == AUDIO_STREAM_CNT); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 657 | } |
| 658 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 659 | virtual bool isTimedTrack() const { return false; } |
| 660 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 661 | // we don't really need a lock for these |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 662 | volatile bool mMute; |
| 663 | // FILLED state is used for suppressing volume ramp at begin of playing |
| 664 | enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; |
| 665 | mutable uint8_t mFillingUpStatus; |
| 666 | int8_t mRetryCount; |
| 667 | sp<IMemory> mSharedBuffer; |
| 668 | bool mResetDone; |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 669 | audio_stream_type_t mStreamType; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 670 | int mName; |
| 671 | int16_t *mMainBuffer; |
| 672 | int32_t *mAuxBuffer; |
| 673 | int mAuxEffectId; |
Eric Laurent | 8f45bd7 | 2010-08-31 13:50:07 -0700 | [diff] [blame] | 674 | bool mHasVolumeController; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 675 | }; // end of Track |
| 676 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 677 | class TimedTrack : public Track { |
| 678 | public: |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 679 | static sp<TimedTrack> create(PlaybackThread *thread, |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 680 | const sp<Client>& client, |
| 681 | audio_stream_type_t streamType, |
| 682 | uint32_t sampleRate, |
| 683 | audio_format_t format, |
| 684 | uint32_t channelMask, |
| 685 | int frameCount, |
| 686 | const sp<IMemory>& sharedBuffer, |
| 687 | int sessionId); |
| 688 | ~TimedTrack(); |
| 689 | |
| 690 | class TimedBuffer { |
| 691 | public: |
| 692 | TimedBuffer(); |
| 693 | TimedBuffer(const sp<IMemory>& buffer, int64_t pts); |
| 694 | const sp<IMemory>& buffer() const { return mBuffer; } |
| 695 | int64_t pts() const { return mPTS; } |
| 696 | int position() const { return mPosition; } |
| 697 | void setPosition(int pos) { mPosition = pos; } |
| 698 | private: |
| 699 | sp<IMemory> mBuffer; |
| 700 | int64_t mPTS; |
| 701 | int mPosition; |
| 702 | }; |
| 703 | |
| 704 | virtual bool isTimedTrack() const { return true; } |
| 705 | |
| 706 | virtual uint32_t framesReady() const; |
| 707 | |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 708 | // AudioBufferProvider interface |
| 709 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts); |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 710 | virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 711 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 712 | void timedYieldSamples(AudioBufferProvider::Buffer* buffer); |
| 713 | void timedYieldSilence(uint32_t numFrames, |
| 714 | AudioBufferProvider::Buffer* buffer); |
| 715 | |
| 716 | status_t allocateTimedBuffer(size_t size, |
| 717 | sp<IMemory>* buffer); |
| 718 | status_t queueTimedBuffer(const sp<IMemory>& buffer, |
| 719 | int64_t pts); |
| 720 | status_t setMediaTimeTransform(const LinearTransform& xform, |
| 721 | TimedAudioTrack::TargetTimeline target); |
| 722 | void trimTimedBufferQueue_l(); |
| 723 | |
| 724 | private: |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 725 | TimedTrack(PlaybackThread *thread, |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 726 | const sp<Client>& client, |
| 727 | audio_stream_type_t streamType, |
| 728 | uint32_t sampleRate, |
| 729 | audio_format_t format, |
| 730 | uint32_t channelMask, |
| 731 | int frameCount, |
| 732 | const sp<IMemory>& sharedBuffer, |
| 733 | int sessionId); |
| 734 | |
| 735 | uint64_t mLocalTimeFreq; |
| 736 | LinearTransform mLocalTimeToSampleTransform; |
| 737 | sp<MemoryDealer> mTimedMemoryDealer; |
| 738 | Vector<TimedBuffer> mTimedBufferQueue; |
| 739 | uint8_t* mTimedSilenceBuffer; |
| 740 | uint32_t mTimedSilenceBufferSize; |
| 741 | mutable Mutex mTimedBufferQueueLock; |
| 742 | bool mTimedAudioOutputOnTime; |
| 743 | CCHelper mCCHelper; |
| 744 | |
| 745 | Mutex mMediaTimeTransformLock; |
| 746 | LinearTransform mMediaTimeTransform; |
| 747 | bool mMediaTimeTransformValid; |
| 748 | TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget; |
| 749 | }; |
| 750 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 751 | |
| 752 | // playback track |
| 753 | class OutputTrack : public Track { |
| 754 | public: |
| 755 | |
| 756 | class Buffer: public AudioBufferProvider::Buffer { |
| 757 | public: |
| 758 | int16_t *mBuffer; |
| 759 | }; |
| 760 | |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 761 | OutputTrack(PlaybackThread *thread, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 762 | DuplicatingThread *sourceThread, |
| 763 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 764 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 765 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 766 | int frameCount); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 767 | virtual ~OutputTrack(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 768 | |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 769 | virtual status_t start(pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 770 | virtual void stop(); |
| 771 | bool write(int16_t* data, uint32_t frames); |
Glenn Kasten | a111792 | 2012-01-26 10:53:32 -0800 | [diff] [blame] | 772 | bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 773 | bool isActive() const { return mActive; } |
| 774 | const wp<ThreadBase>& thread() const { return mThread; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 775 | |
| 776 | private: |
| 777 | |
Glenn Kasten | 335787f | 2012-01-20 17:00:00 -0800 | [diff] [blame] | 778 | enum { |
| 779 | NO_MORE_BUFFERS = 0x80000001, // same in AudioTrack.h, ok to be different value |
| 780 | }; |
| 781 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 782 | status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs); |
| 783 | void clearBufferQueue(); |
| 784 | |
| 785 | // Maximum number of pending buffers allocated by OutputTrack::write() |
| 786 | static const uint8_t kMaxOverFlowBuffers = 10; |
| 787 | |
| 788 | Vector < Buffer* > mBufferQueue; |
| 789 | AudioBufferProvider::Buffer mOutBuffer; |
| 790 | bool mActive; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 791 | DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 792 | }; // end of OutputTrack |
| 793 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 794 | PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, |
| 795 | audio_io_handle_t id, uint32_t device, type_t type); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 796 | virtual ~PlaybackThread(); |
| 797 | |
| 798 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 799 | |
| 800 | // Thread virtuals |
| 801 | virtual status_t readyToRun(); |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 802 | virtual bool threadLoop(); |
| 803 | |
| 804 | // RefBase |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 805 | virtual void onFirstRef(); |
| 806 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 807 | protected: |
| 808 | // Code snippets that were lifted up out of threadLoop() |
| 809 | virtual void threadLoop_mix() = 0; |
| 810 | virtual void threadLoop_sleepTime() = 0; |
| 811 | virtual void threadLoop_write(); |
| 812 | virtual void threadLoop_standby(); |
| 813 | |
| 814 | // Non-trivial for DUPLICATING only |
Glenn Kasten | 438b036 | 2012-03-06 11:24:48 -0800 | [diff] [blame] | 815 | virtual void updateWaitTime_l() { } |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 816 | |
| 817 | // Non-trivial for DIRECT only |
| 818 | virtual void applyVolume() { } |
| 819 | |
| 820 | // FIXME merge these |
| 821 | // Non-trivial for MIXER and DUPLICATING only |
| 822 | virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) { return MIXER_IDLE; } |
| 823 | // Non-trivial for DIRECT only |
| 824 | virtual mixer_state threadLoop_prepareTracks_l(sp<Track>& trackToRemove) |
| 825 | { return MIXER_IDLE; } |
| 826 | |
| 827 | public: |
| 828 | |
Glenn Kasten | e0feee3 | 2011-12-13 11:53:26 -0800 | [diff] [blame] | 829 | virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 830 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 831 | virtual uint32_t latency() const; |
| 832 | |
Glenn Kasten | 6637baa | 2012-01-09 09:40:36 -0800 | [diff] [blame] | 833 | void setMasterVolume(float value); |
| 834 | void setMasterMute(bool muted); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 835 | |
Glenn Kasten | 6637baa | 2012-01-09 09:40:36 -0800 | [diff] [blame] | 836 | void setStreamVolume(audio_stream_type_t stream, float value); |
| 837 | void setStreamMute(audio_stream_type_t stream, bool muted); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 838 | |
Glenn Kasten | 6637baa | 2012-01-09 09:40:36 -0800 | [diff] [blame] | 839 | float streamVolume(audio_stream_type_t stream) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 840 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 841 | sp<Track> createTrack_l( |
| 842 | const sp<AudioFlinger::Client>& client, |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 843 | audio_stream_type_t streamType, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 844 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 845 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 846 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 847 | int frameCount, |
| 848 | const sp<IMemory>& sharedBuffer, |
| 849 | int sessionId, |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 850 | bool isTimed, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 851 | status_t *status); |
| 852 | |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 853 | AudioStreamOut* getOutput() const; |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 854 | AudioStreamOut* clearOutput(); |
| 855 | virtual audio_stream_t* stream(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 856 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 857 | void suspend() { mSuspended++; } |
Glenn Kasten | c455fe9 | 2012-02-29 07:07:30 -0800 | [diff] [blame] | 858 | void restore() { if (mSuspended > 0) mSuspended--; } |
| 859 | bool isSuspended() const { return (mSuspended > 0); } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 860 | virtual String8 getParameters(const String8& keys); |
| 861 | virtual void audioConfigChanged_l(int event, int param = 0); |
| 862 | virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 863 | int16_t *mixBuffer() const { return mMixBuffer; }; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 864 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 865 | virtual void detachAuxEffect_l(int effectId); |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 866 | status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, |
| 867 | int EffectId); |
| 868 | status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, |
| 869 | int EffectId); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 870 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 871 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain); |
| 872 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); |
| 873 | virtual uint32_t hasAudioSession(int sessionId); |
| 874 | virtual uint32_t getStrategyForSession_l(int sessionId); |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 875 | |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 876 | void setStreamValid(audio_stream_type_t streamType, bool valid); |
Eric Laurent | 9f6530f | 2011-08-30 10:18:54 -0700 | [diff] [blame] | 877 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 878 | protected: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 879 | int16_t* mMixBuffer; |
Glenn Kasten | c455fe9 | 2012-02-29 07:07:30 -0800 | [diff] [blame] | 880 | uint32_t mSuspended; // suspend count, > 0 means suspended |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 881 | int mBytesWritten; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 882 | private: |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 883 | // mMasterMute is in both PlaybackThread and in AudioFlinger. When a |
| 884 | // PlaybackThread needs to find out if master-muted, it checks it's local |
| 885 | // copy rather than the one in AudioFlinger. This optimization saves a lock. |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 886 | bool mMasterMute; |
Glenn Kasten | 6637baa | 2012-01-09 09:40:36 -0800 | [diff] [blame] | 887 | void setMasterMute_l(bool muted) { mMasterMute = muted; } |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 888 | protected: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 889 | SortedVector< wp<Track> > mActiveTracks; |
| 890 | |
| 891 | virtual int getTrackName_l() = 0; |
| 892 | virtual void deleteTrackName_l(int name) = 0; |
Eric Laurent | 162b40b | 2011-12-05 09:47:19 -0800 | [diff] [blame] | 893 | virtual uint32_t activeSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 894 | virtual uint32_t idleSleepTimeUs() = 0; |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 895 | virtual uint32_t suspendSleepTimeUs() = 0; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 896 | |
Glenn Kasten | 37d825e | 2012-02-24 07:21:48 -0800 | [diff] [blame] | 897 | // Code snippets that are temporarily lifted up out of threadLoop() until the merge |
| 898 | void checkSilentMode_l(); |
| 899 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 900 | private: |
| 901 | |
| 902 | friend class AudioFlinger; |
| 903 | friend class OutputTrack; |
| 904 | friend class Track; |
| 905 | friend class TrackBase; |
| 906 | friend class MixerThread; |
| 907 | friend class DirectOutputThread; |
| 908 | friend class DuplicatingThread; |
| 909 | |
| 910 | PlaybackThread(const Client&); |
| 911 | PlaybackThread& operator = (const PlaybackThread&); |
| 912 | |
| 913 | status_t addTrack_l(const sp<Track>& track); |
| 914 | void destroyTrack_l(const sp<Track>& track); |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 915 | void removeTrack_l(const sp<Track>& track); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 916 | |
| 917 | void readOutputParameters(); |
| 918 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 919 | virtual status_t dumpInternals(int fd, const Vector<String16>& args); |
| 920 | status_t dumpTracks(int fd, const Vector<String16>& args); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 921 | |
| 922 | SortedVector< sp<Track> > mTracks; |
Glenn Kasten | 263709e | 2012-01-06 08:40:01 -0800 | [diff] [blame] | 923 | // mStreamTypes[] uses 1 additional stream type internally for the OutputTrack used by DuplicatingThread |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 924 | stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1]; |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 925 | AudioStreamOut *mOutput; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 926 | float mMasterVolume; |
| 927 | nsecs_t mLastWriteTime; |
| 928 | int mNumWrites; |
| 929 | int mNumDelayedWrites; |
| 930 | bool mInWrite; |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 931 | |
| 932 | // FIXME rename these former local variables of threadLoop to standard "m" names |
| 933 | nsecs_t standbyTime; |
| 934 | size_t mixBufferSize; |
| 935 | uint32_t activeSleepTime; |
| 936 | uint32_t idleSleepTime; |
| 937 | uint32_t sleepTime; |
| 938 | // mixerStatus was local to the while !exitingPending loop |
| 939 | mixer_state mixerStatus; |
| 940 | |
| 941 | // FIXME move these declarations into the specific sub-class that needs them |
| 942 | // MIXER only |
| 943 | bool longStandbyExit; |
| 944 | uint32_t sleepTimeShift; |
| 945 | // MIXER and DUPLICATING only |
| 946 | mixer_state mPrevMixerStatus; // previous status returned by prepareTracks_l() |
| 947 | // DIRECT only |
| 948 | nsecs_t standbyDelay; |
| 949 | // activeTrack was local to the while !exitingPending loop |
| 950 | sp<Track> activeTrack; |
| 951 | // DUPLICATING only |
| 952 | SortedVector < sp<OutputTrack> > outputTracks; |
| 953 | uint32_t writeFrames; |
| 954 | SortedVector < sp<OutputTrack> > mOutputTracks; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 955 | }; |
| 956 | |
| 957 | class MixerThread : public PlaybackThread { |
| 958 | public: |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 959 | MixerThread (const sp<AudioFlinger>& audioFlinger, |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 960 | AudioStreamOut* output, |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 961 | audio_io_handle_t id, |
Glenn Kasten | 23bb8be | 2012-01-26 10:38:26 -0800 | [diff] [blame] | 962 | uint32_t device, |
| 963 | type_t type = MIXER); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 964 | virtual ~MixerThread(); |
| 965 | |
| 966 | // Thread virtuals |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 967 | |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 968 | void invalidateTracks(audio_stream_type_t streamType); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 969 | virtual bool checkForNewParameters_l(); |
| 970 | virtual status_t dumpInternals(int fd, const Vector<String16>& args); |
| 971 | |
| 972 | protected: |
Glenn Kasten | 3e07470 | 2012-02-28 18:40:35 -0800 | [diff] [blame] | 973 | // prepareTracks_l reads and writes mActiveTracks, and also returns the |
| 974 | // pending set of tracks to remove via Vector 'tracksToRemove'. The caller is |
| 975 | // responsible for clearing or destroying this Vector later on, when it |
| 976 | // is safe to do so. That will drop the final ref count and destroy the tracks. |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 977 | virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 978 | virtual int getTrackName_l(); |
| 979 | virtual void deleteTrackName_l(int name); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 980 | virtual uint32_t idleSleepTimeUs(); |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 981 | virtual uint32_t suspendSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 982 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 983 | // threadLoop snippets |
| 984 | virtual void threadLoop_mix(); |
| 985 | virtual void threadLoop_sleepTime(); |
| 986 | |
Eric Laurent | 2774144 | 2012-01-17 19:20:12 -0800 | [diff] [blame] | 987 | AudioMixer* mAudioMixer; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 988 | }; |
| 989 | |
| 990 | class DirectOutputThread : public PlaybackThread { |
| 991 | public: |
| 992 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 993 | DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, |
| 994 | audio_io_handle_t id, uint32_t device); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 995 | virtual ~DirectOutputThread(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 996 | |
| 997 | // Thread virtuals |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 998 | |
| 999 | virtual bool checkForNewParameters_l(); |
| 1000 | |
| 1001 | protected: |
| 1002 | virtual int getTrackName_l(); |
| 1003 | virtual void deleteTrackName_l(int name); |
| 1004 | virtual uint32_t activeSleepTimeUs(); |
| 1005 | virtual uint32_t idleSleepTimeUs(); |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 1006 | virtual uint32_t suspendSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1007 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1008 | // threadLoop snippets |
| 1009 | virtual mixer_state threadLoop_prepareTracks_l(sp<Track>& trackToRemove); |
| 1010 | virtual void threadLoop_mix(); |
| 1011 | virtual void threadLoop_sleepTime(); |
| 1012 | virtual void applyVolume(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1013 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1014 | // volumes last sent to audio HAL with stream->set_volume() |
| 1015 | // FIXME use standard representation and names |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1016 | float mLeftVolFloat; |
| 1017 | float mRightVolFloat; |
| 1018 | uint16_t mLeftVolShort; |
| 1019 | uint16_t mRightVolShort; |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1020 | |
| 1021 | // FIXME rename these former local variables of threadLoop to standard names |
| 1022 | // next 3 were local to the while !exitingPending loop |
| 1023 | bool rampVolume; |
| 1024 | uint16_t leftVol; |
| 1025 | uint16_t rightVol; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1026 | }; |
| 1027 | |
| 1028 | class DuplicatingThread : public MixerThread { |
| 1029 | public: |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1030 | DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, |
| 1031 | audio_io_handle_t id); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 1032 | virtual ~DuplicatingThread(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1033 | |
| 1034 | // Thread virtuals |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1035 | void addOutputTrack(MixerThread* thread); |
| 1036 | void removeOutputTrack(MixerThread* thread); |
| 1037 | uint32_t waitTimeMs() { return mWaitTimeMs; } |
| 1038 | protected: |
| 1039 | virtual uint32_t activeSleepTimeUs(); |
| 1040 | |
| 1041 | private: |
Glenn Kasten | 02fe1bf | 2012-02-24 15:42:17 -0800 | [diff] [blame] | 1042 | bool outputsReady(const SortedVector<sp<OutputTrack> > &outputTracks); |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1043 | protected: |
| 1044 | // threadLoop snippets |
| 1045 | virtual void threadLoop_mix(); |
| 1046 | virtual void threadLoop_sleepTime(); |
| 1047 | virtual void threadLoop_write(); |
| 1048 | virtual void threadLoop_standby(); |
Glenn Kasten | 438b036 | 2012-03-06 11:24:48 -0800 | [diff] [blame] | 1049 | |
| 1050 | // called from threadLoop, addOutputTrack, removeOutputTrack |
| 1051 | virtual void updateWaitTime_l(); |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1052 | private: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1053 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1054 | uint32_t mWaitTimeMs; |
| 1055 | }; |
| 1056 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1057 | PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const; |
| 1058 | MixerThread *checkMixerThread_l(audio_io_handle_t output) const; |
| 1059 | RecordThread *checkRecordThread_l(audio_io_handle_t input) const; |
Glenn Kasten | 6637baa | 2012-01-09 09:40:36 -0800 | [diff] [blame] | 1060 | // no range check, AudioFlinger::mLock held |
| 1061 | bool streamMute_l(audio_stream_type_t stream) const |
| 1062 | { return mStreamTypes[stream].mute; } |
| 1063 | // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held |
| 1064 | float streamVolume_l(audio_stream_type_t stream) const |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1065 | { return mStreamTypes[stream].volume; } |
Glenn Kasten | b81cc8c | 2012-03-01 09:14:51 -0800 | [diff] [blame^] | 1066 | void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1067 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1068 | // allocate an audio_io_handle_t, session ID, or effect ID |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1069 | uint32_t nextUniqueId(); |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1070 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1071 | status_t moveEffectChain_l(int sessionId, |
Glenn Kasten | a111792 | 2012-01-26 10:53:32 -0800 | [diff] [blame] | 1072 | PlaybackThread *srcThread, |
| 1073 | PlaybackThread *dstThread, |
Eric Laurent | 39e94f8 | 2010-07-28 01:32:47 -0700 | [diff] [blame] | 1074 | bool reRegister); |
Glenn Kasten | 02fe1bf | 2012-02-24 15:42:17 -0800 | [diff] [blame] | 1075 | // return thread associated with primary hardware device, or NULL |
| 1076 | PlaybackThread *primaryPlaybackThread_l() const; |
| 1077 | uint32_t primaryOutputDevice_l() const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1078 | |
| 1079 | friend class AudioBuffer; |
| 1080 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1081 | // server side of the client's IAudioTrack |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1082 | class TrackHandle : public android::BnAudioTrack { |
| 1083 | public: |
| 1084 | TrackHandle(const sp<PlaybackThread::Track>& track); |
| 1085 | virtual ~TrackHandle(); |
Glenn Kasten | 90716c5 | 2012-01-26 13:40:12 -0800 | [diff] [blame] | 1086 | virtual sp<IMemory> getCblk() const; |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 1087 | virtual status_t start(pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1088 | virtual void stop(); |
| 1089 | virtual void flush(); |
| 1090 | virtual void mute(bool); |
| 1091 | virtual void pause(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1092 | virtual status_t attachAuxEffect(int effectId); |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 1093 | virtual status_t allocateTimedBuffer(size_t size, |
| 1094 | sp<IMemory>* buffer); |
| 1095 | virtual status_t queueTimedBuffer(const sp<IMemory>& buffer, |
| 1096 | int64_t pts); |
| 1097 | virtual status_t setMediaTimeTransform(const LinearTransform& xform, |
| 1098 | int target); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1099 | virtual status_t onTransact( |
| 1100 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 1101 | private: |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 1102 | const sp<PlaybackThread::Track> mTrack; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1103 | }; |
| 1104 | |
| 1105 | friend class Client; |
| 1106 | friend class PlaybackThread::Track; |
| 1107 | |
| 1108 | |
| 1109 | void removeClient_l(pid_t pid); |
| 1110 | void removeNotificationClient(pid_t pid); |
| 1111 | |
| 1112 | |
| 1113 | // record thread |
| 1114 | class RecordThread : public ThreadBase, public AudioBufferProvider |
| 1115 | { |
| 1116 | public: |
| 1117 | |
| 1118 | // record track |
| 1119 | class RecordTrack : public TrackBase { |
| 1120 | public: |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 1121 | RecordTrack(RecordThread *thread, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1122 | const sp<Client>& client, |
| 1123 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 1124 | audio_format_t format, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 1125 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1126 | int frameCount, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1127 | int sessionId); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 1128 | virtual ~RecordTrack(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1129 | |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 1130 | virtual status_t start(pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1131 | virtual void stop(); |
| 1132 | |
| 1133 | bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; } |
| 1134 | bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; } |
| 1135 | |
| 1136 | void dump(char* buffer, size_t size); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1137 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1138 | private: |
| 1139 | friend class AudioFlinger; |
| 1140 | friend class RecordThread; |
| 1141 | |
| 1142 | RecordTrack(const RecordTrack&); |
| 1143 | RecordTrack& operator = (const RecordTrack&); |
| 1144 | |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 1145 | // AudioBufferProvider interface |
| 1146 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS); |
| 1147 | // releaseBuffer() not overridden |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1148 | |
| 1149 | bool mOverflow; |
| 1150 | }; |
| 1151 | |
| 1152 | |
| 1153 | RecordThread(const sp<AudioFlinger>& audioFlinger, |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1154 | AudioStreamIn *input, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1155 | uint32_t sampleRate, |
| 1156 | uint32_t channels, |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1157 | audio_io_handle_t id, |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1158 | uint32_t device); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 1159 | virtual ~RecordThread(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1160 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1161 | // Thread |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1162 | virtual bool threadLoop(); |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 1163 | virtual status_t readyToRun(); |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 1164 | |
| 1165 | // RefBase |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1166 | virtual void onFirstRef(); |
| 1167 | |
Glenn Kasten | e0feee3 | 2011-12-13 11:53:26 -0800 | [diff] [blame] | 1168 | virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1169 | sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( |
| 1170 | const sp<AudioFlinger::Client>& client, |
| 1171 | uint32_t sampleRate, |
Glenn Kasten | 58f3021 | 2012-01-12 12:27:51 -0800 | [diff] [blame] | 1172 | audio_format_t format, |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1173 | int channelMask, |
| 1174 | int frameCount, |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1175 | int sessionId, |
| 1176 | status_t *status); |
| 1177 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1178 | status_t start(RecordTrack* recordTrack); |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 1179 | status_t start(RecordTrack* recordTrack, pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1180 | void stop(RecordTrack* recordTrack); |
| 1181 | status_t dump(int fd, const Vector<String16>& args); |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 1182 | AudioStreamIn* getInput() const; |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 1183 | AudioStreamIn* clearInput(); |
| 1184 | virtual audio_stream_t* stream(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1185 | |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 1186 | // AudioBufferProvider interface |
| 1187 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1188 | virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); |
Glenn Kasten | 01c4ebf | 2012-02-22 10:47:35 -0800 | [diff] [blame] | 1189 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1190 | virtual bool checkForNewParameters_l(); |
| 1191 | virtual String8 getParameters(const String8& keys); |
| 1192 | virtual void audioConfigChanged_l(int event, int param = 0); |
| 1193 | void readInputParameters(); |
| 1194 | virtual unsigned int getInputFramesLost(); |
| 1195 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1196 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain); |
| 1197 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); |
| 1198 | virtual uint32_t hasAudioSession(int sessionId); |
Eric Laurent | 59bd0da | 2011-08-01 09:52:20 -0700 | [diff] [blame] | 1199 | RecordTrack* track(); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1200 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1201 | private: |
| 1202 | RecordThread(); |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1203 | AudioStreamIn *mInput; |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1204 | RecordTrack* mTrack; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1205 | sp<RecordTrack> mActiveTrack; |
| 1206 | Condition mStartStopCond; |
| 1207 | AudioResampler *mResampler; |
| 1208 | int32_t *mRsmpOutBuffer; |
| 1209 | int16_t *mRsmpInBuffer; |
| 1210 | size_t mRsmpInIndex; |
| 1211 | size_t mInputBytes; |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 1212 | const int mReqChannelCount; |
| 1213 | const uint32_t mReqSampleRate; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1214 | ssize_t mBytesRead; |
| 1215 | }; |
| 1216 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1217 | // server side of the client's IAudioRecord |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1218 | class RecordHandle : public android::BnAudioRecord { |
| 1219 | public: |
| 1220 | RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); |
| 1221 | virtual ~RecordHandle(); |
Glenn Kasten | 90716c5 | 2012-01-26 13:40:12 -0800 | [diff] [blame] | 1222 | virtual sp<IMemory> getCblk() const; |
Glenn Kasten | 6dbc135 | 2012-02-02 10:56:47 -0800 | [diff] [blame] | 1223 | virtual status_t start(pid_t tid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1224 | virtual void stop(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1225 | virtual status_t onTransact( |
| 1226 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 1227 | private: |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 1228 | const sp<RecordThread::RecordTrack> mRecordTrack; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1229 | }; |
| 1230 | |
| 1231 | //--- Audio Effect Management |
| 1232 | |
| 1233 | // EffectModule and EffectChain classes both have their own mutex to protect |
| 1234 | // state changes or resource modifications. Always respect the following order |
| 1235 | // if multiple mutexes must be acquired to avoid cross deadlock: |
| 1236 | // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule |
| 1237 | |
| 1238 | // The EffectModule class is a wrapper object controlling the effect engine implementation |
| 1239 | // in the effect library. It prevents concurrent calls to process() and command() functions |
| 1240 | // from different client threads. It keeps a list of EffectHandle objects corresponding |
| 1241 | // to all client applications using this effect and notifies applications of effect state, |
| 1242 | // control or parameter changes. It manages the activation state machine to send appropriate |
| 1243 | // reset, enable, disable commands to effect engine and provide volume |
| 1244 | // ramping when effects are activated/deactivated. |
| 1245 | // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by |
| 1246 | // the attached track(s) to accumulate their auxiliary channel. |
| 1247 | class EffectModule: public RefBase { |
| 1248 | public: |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 1249 | EffectModule(ThreadBase *thread, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1250 | const wp<AudioFlinger::EffectChain>& chain, |
| 1251 | effect_descriptor_t *desc, |
| 1252 | int id, |
| 1253 | int sessionId); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 1254 | virtual ~EffectModule(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1255 | |
| 1256 | enum effect_state { |
| 1257 | IDLE, |
| 1258 | RESTART, |
| 1259 | STARTING, |
| 1260 | ACTIVE, |
| 1261 | STOPPING, |
Eric Laurent | ec437d8 | 2011-07-26 20:54:46 -0700 | [diff] [blame] | 1262 | STOPPED, |
| 1263 | DESTROYED |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1264 | }; |
| 1265 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1266 | int id() const { return mId; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1267 | void process(); |
| 1268 | void updateState(); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1269 | status_t command(uint32_t cmdCode, |
| 1270 | uint32_t cmdSize, |
| 1271 | void *pCmdData, |
| 1272 | uint32_t *replySize, |
| 1273 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1274 | |
| 1275 | void reset_l(); |
| 1276 | status_t configure(); |
| 1277 | status_t init(); |
Glenn Kasten | 28243dd | 2012-01-26 13:43:46 -0800 | [diff] [blame] | 1278 | effect_state state() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1279 | return mState; |
| 1280 | } |
| 1281 | uint32_t status() { |
| 1282 | return mStatus; |
| 1283 | } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1284 | int sessionId() const { |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1285 | return mSessionId; |
| 1286 | } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1287 | status_t setEnabled(bool enabled); |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1288 | bool isEnabled() const; |
| 1289 | bool isProcessEnabled() const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1290 | |
| 1291 | void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; } |
| 1292 | int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; } |
| 1293 | void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; } |
| 1294 | int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1295 | void setChain(const wp<EffectChain>& chain) { mChain = chain; } |
| 1296 | void setThread(const wp<ThreadBase>& thread) { mThread = thread; } |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 1297 | const wp<ThreadBase>& thread() { return mThread; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1298 | |
Glenn Kasten | 435dbe6 | 2012-01-30 10:15:48 -0800 | [diff] [blame] | 1299 | status_t addHandle(const sp<EffectHandle>& handle); |
Glenn Kasten | 58123c3 | 2012-02-03 10:32:24 -0800 | [diff] [blame] | 1300 | void disconnect(const wp<EffectHandle>& handle, bool unpinIfLast); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1301 | size_t removeHandle (const wp<EffectHandle>& handle); |
| 1302 | |
| 1303 | effect_descriptor_t& desc() { return mDescriptor; } |
| 1304 | wp<EffectChain>& chain() { return mChain; } |
| 1305 | |
| 1306 | status_t setDevice(uint32_t device); |
| 1307 | status_t setVolume(uint32_t *left, uint32_t *right, bool controller); |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 1308 | status_t setMode(audio_mode_t mode); |
Eric Laurent | ec35a14 | 2011-10-05 17:42:25 -0700 | [diff] [blame] | 1309 | status_t start(); |
Eric Laurent | ec437d8 | 2011-07-26 20:54:46 -0700 | [diff] [blame] | 1310 | status_t stop(); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1311 | void setSuspended(bool suspended); |
Glenn Kasten | a3a8548 | 2012-01-04 11:01:11 -0800 | [diff] [blame] | 1312 | bool suspended() const; |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1313 | |
| 1314 | sp<EffectHandle> controlHandle(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1315 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1316 | bool isPinned() const { return mPinned; } |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1317 | void unPin() { mPinned = false; } |
| 1318 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1319 | status_t dump(int fd, const Vector<String16>& args); |
| 1320 | |
| 1321 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1322 | friend class EffectHandle; |
| 1323 | friend class AudioFlinger; |
| 1324 | bool mPinned; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1325 | |
| 1326 | // Maximum time allocated to effect engines to complete the turn off sequence |
| 1327 | static const uint32_t MAX_DISABLE_TIME_MS = 10000; |
| 1328 | |
| 1329 | EffectModule(const EffectModule&); |
| 1330 | EffectModule& operator = (const EffectModule&); |
| 1331 | |
| 1332 | status_t start_l(); |
| 1333 | status_t stop_l(); |
| 1334 | |
Glenn Kasten | a3a8548 | 2012-01-04 11:01:11 -0800 | [diff] [blame] | 1335 | mutable Mutex mLock; // mutex for process, commands and handles list protection |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1336 | wp<ThreadBase> mThread; // parent thread |
| 1337 | wp<EffectChain> mChain; // parent effect chain |
| 1338 | int mId; // this instance unique ID |
| 1339 | int mSessionId; // audio session ID |
| 1340 | effect_descriptor_t mDescriptor;// effect descriptor received from effect engine |
| 1341 | effect_config_t mConfig; // input and output audio configuration |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 1342 | effect_handle_t mEffectInterface; // Effect module C API |
Glenn Kasten | 28243dd | 2012-01-26 13:43:46 -0800 | [diff] [blame] | 1343 | status_t mStatus; // initialization status |
| 1344 | effect_state mState; // current activation state |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1345 | Vector< wp<EffectHandle> > mHandles; // list of client handles |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1346 | // First handle in mHandles has highest priority and controls the effect module |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1347 | uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after |
| 1348 | // sending disable command. |
| 1349 | uint32_t mDisableWaitCnt; // current process() calls count during disable period. |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1350 | bool mSuspended; // effect is suspended: temporarily disabled by framework |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1351 | }; |
| 1352 | |
| 1353 | // The EffectHandle class implements the IEffect interface. It provides resources |
| 1354 | // to receive parameter updates, keeps track of effect control |
| 1355 | // ownership and state and has a pointer to the EffectModule object it is controlling. |
| 1356 | // There is one EffectHandle object for each application controlling (or using) |
| 1357 | // an effect module. |
| 1358 | // The EffectHandle is obtained by calling AudioFlinger::createEffect(). |
| 1359 | class EffectHandle: public android::BnEffect { |
| 1360 | public: |
| 1361 | |
| 1362 | EffectHandle(const sp<EffectModule>& effect, |
| 1363 | const sp<AudioFlinger::Client>& client, |
| 1364 | const sp<IEffectClient>& effectClient, |
| 1365 | int32_t priority); |
| 1366 | virtual ~EffectHandle(); |
| 1367 | |
| 1368 | // IEffect |
| 1369 | virtual status_t enable(); |
| 1370 | virtual status_t disable(); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1371 | virtual status_t command(uint32_t cmdCode, |
| 1372 | uint32_t cmdSize, |
| 1373 | void *pCmdData, |
| 1374 | uint32_t *replySize, |
| 1375 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1376 | virtual void disconnect(); |
Glenn Kasten | 58123c3 | 2012-02-03 10:32:24 -0800 | [diff] [blame] | 1377 | private: |
| 1378 | void disconnect(bool unpinIfLast); |
| 1379 | public: |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1380 | virtual sp<IMemory> getCblk() const { return mCblkMemory; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1381 | virtual status_t onTransact(uint32_t code, const Parcel& data, |
| 1382 | Parcel* reply, uint32_t flags); |
| 1383 | |
| 1384 | |
| 1385 | // Give or take control of effect module |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1386 | // - hasControl: true if control is given, false if removed |
| 1387 | // - signal: true client app should be signaled of change, false otherwise |
| 1388 | // - enabled: state of the effect when control is passed |
| 1389 | void setControl(bool hasControl, bool signal, bool enabled); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1390 | void commandExecuted(uint32_t cmdCode, |
| 1391 | uint32_t cmdSize, |
| 1392 | void *pCmdData, |
| 1393 | uint32_t replySize, |
| 1394 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1395 | void setEnabled(bool enabled); |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1396 | bool enabled() const { return mEnabled; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1397 | |
| 1398 | // Getters |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1399 | int id() const { return mEffect->id(); } |
| 1400 | int priority() const { return mPriority; } |
| 1401 | bool hasControl() const { return mHasControl; } |
| 1402 | sp<EffectModule> effect() const { return mEffect; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1403 | |
| 1404 | void dump(char* buffer, size_t size); |
| 1405 | |
| 1406 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1407 | friend class AudioFlinger; |
| 1408 | friend class EffectModule; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1409 | EffectHandle(const EffectHandle&); |
| 1410 | EffectHandle& operator =(const EffectHandle&); |
| 1411 | |
| 1412 | sp<EffectModule> mEffect; // pointer to controlled EffectModule |
| 1413 | sp<IEffectClient> mEffectClient; // callback interface for client notifications |
Glenn Kasten | 98ec94c | 2012-01-25 14:28:29 -0800 | [diff] [blame] | 1414 | /*const*/ sp<Client> mClient; // client for shared memory allocation, see disconnect() |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1415 | sp<IMemory> mCblkMemory; // shared memory for control block |
| 1416 | effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory |
| 1417 | uint8_t* mBuffer; // pointer to parameter area in shared memory |
| 1418 | int mPriority; // client application priority to control the effect |
| 1419 | bool mHasControl; // true if this handle is controlling the effect |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1420 | bool mEnabled; // cached enable state: needed when the effect is |
| 1421 | // restored after being suspended |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1422 | }; |
| 1423 | |
| 1424 | // the EffectChain class represents a group of effects associated to one audio session. |
| 1425 | // There can be any number of EffectChain objects per output mixer thread (PlaybackThread). |
| 1426 | // The EffecChain with session ID 0 contains global effects applied to the output mix. |
| 1427 | // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks) |
| 1428 | // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding |
| 1429 | // in the effect process order. When attached to a track (session ID != 0), it also provide it's own |
| 1430 | // input buffer used by the track as accumulation buffer. |
| 1431 | class EffectChain: public RefBase { |
| 1432 | public: |
| 1433 | EffectChain(const wp<ThreadBase>& wThread, int sessionId); |
Glenn Kasten | 9eaa557 | 2012-01-20 13:32:16 -0800 | [diff] [blame] | 1434 | EffectChain(ThreadBase *thread, int sessionId); |
Glenn Kasten | c19e224 | 2012-01-30 14:54:39 -0800 | [diff] [blame] | 1435 | virtual ~EffectChain(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1436 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1437 | // special key used for an entry in mSuspendedEffects keyed vector |
| 1438 | // corresponding to a suspend all request. |
| 1439 | static const int kKeyForSuspendAll = 0; |
| 1440 | |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1441 | // minimum duration during which we force calling effect process when last track on |
| 1442 | // a session is stopped or removed to allow effect tail to be rendered |
| 1443 | static const int kProcessTailDurationMs = 1000; |
| 1444 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1445 | void process_l(); |
| 1446 | |
| 1447 | void lock() { |
| 1448 | mLock.lock(); |
| 1449 | } |
| 1450 | void unlock() { |
| 1451 | mLock.unlock(); |
| 1452 | } |
| 1453 | |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1454 | status_t addEffect_l(const sp<EffectModule>& handle); |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1455 | size_t removeEffect_l(const sp<EffectModule>& handle); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1456 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1457 | int sessionId() const { return mSessionId; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1458 | void setSessionId(int sessionId) { mSessionId = sessionId; } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1459 | |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1460 | sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor); |
| 1461 | sp<EffectModule> getEffectFromId_l(int id); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1462 | sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type); |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1463 | bool setVolume_l(uint32_t *left, uint32_t *right); |
| 1464 | void setDevice_l(uint32_t device); |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 1465 | void setMode_l(audio_mode_t mode); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1466 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1467 | void setInBuffer(int16_t *buffer, bool ownsBuffer = false) { |
| 1468 | mInBuffer = buffer; |
| 1469 | mOwnInBuffer = ownsBuffer; |
| 1470 | } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1471 | int16_t *inBuffer() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1472 | return mInBuffer; |
| 1473 | } |
| 1474 | void setOutBuffer(int16_t *buffer) { |
| 1475 | mOutBuffer = buffer; |
| 1476 | } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1477 | int16_t *outBuffer() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1478 | return mOutBuffer; |
| 1479 | } |
| 1480 | |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1481 | void incTrackCnt() { android_atomic_inc(&mTrackCnt); } |
| 1482 | void decTrackCnt() { android_atomic_dec(&mTrackCnt); } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1483 | int32_t trackCnt() const { return mTrackCnt;} |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1484 | |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1485 | void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt); |
| 1486 | mTailBufferCount = mMaxTailBuffers; } |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1487 | void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); } |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1488 | int32_t activeTrackCnt() const { return mActiveTrackCnt;} |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1489 | |
Glenn Kasten | c59c004 | 2012-02-02 14:06:11 -0800 | [diff] [blame] | 1490 | uint32_t strategy() const { return mStrategy; } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1491 | void setStrategy(uint32_t strategy) |
| 1492 | { mStrategy = strategy; } |
| 1493 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1494 | // suspend effect of the given type |
| 1495 | void setEffectSuspended_l(const effect_uuid_t *type, |
| 1496 | bool suspend); |
| 1497 | // suspend all eligible effects |
| 1498 | void setEffectSuspendedAll_l(bool suspend); |
| 1499 | // check if effects should be suspend or restored when a given effect is enable or disabled |
Eric Laurent | a85a74a | 2011-10-19 11:44:54 -0700 | [diff] [blame] | 1500 | void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1501 | bool enabled); |
| 1502 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1503 | status_t dump(int fd, const Vector<String16>& args); |
| 1504 | |
| 1505 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1506 | friend class AudioFlinger; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1507 | EffectChain(const EffectChain&); |
| 1508 | EffectChain& operator =(const EffectChain&); |
| 1509 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1510 | class SuspendedEffectDesc : public RefBase { |
| 1511 | public: |
| 1512 | SuspendedEffectDesc() : mRefCount(0) {} |
| 1513 | |
| 1514 | int mRefCount; |
| 1515 | effect_uuid_t mType; |
| 1516 | wp<EffectModule> mEffect; |
| 1517 | }; |
| 1518 | |
| 1519 | // get a list of effect modules to suspend when an effect of the type |
| 1520 | // passed is enabled. |
Glenn Kasten | d053971 | 2012-01-30 12:56:03 -0800 | [diff] [blame] | 1521 | void getSuspendEligibleEffects(Vector< sp<EffectModule> > &effects); |
| 1522 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1523 | // get an effect module if it is currently enable |
| 1524 | sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type); |
Eric Laurent | db7c079 | 2011-08-10 10:37:50 -0700 | [diff] [blame] | 1525 | // true if the effect whose descriptor is passed can be suspended |
| 1526 | // OEMs can modify the rules implemented in this method to exclude specific effect |
| 1527 | // types or implementations from the suspend/restore mechanism. |
| 1528 | bool isEffectEligibleForSuspend(const effect_descriptor_t& desc); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1529 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1530 | wp<ThreadBase> mThread; // parent mixer thread |
| 1531 | Mutex mLock; // mutex protecting effect list |
| 1532 | Vector<sp<EffectModule> > mEffects; // list of effect modules |
| 1533 | int mSessionId; // audio session ID |
| 1534 | int16_t *mInBuffer; // chain input buffer |
| 1535 | int16_t *mOutBuffer; // chain output buffer |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1536 | volatile int32_t mActiveTrackCnt; // number of active tracks connected |
| 1537 | volatile int32_t mTrackCnt; // number of tracks connected |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1538 | int32_t mTailBufferCount; // current effect tail buffer count |
| 1539 | int32_t mMaxTailBuffers; // maximum effect tail buffers |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1540 | bool mOwnInBuffer; // true if the chain owns its input buffer |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1541 | int mVolumeCtrlIdx; // index of insert effect having control over volume |
| 1542 | uint32_t mLeftVolume; // previous volume on left channel |
| 1543 | uint32_t mRightVolume; // previous volume on right channel |
Eric Laurent | f997cab | 2010-07-19 06:24:46 -0700 | [diff] [blame] | 1544 | uint32_t mNewLeftVolume; // new volume on left channel |
| 1545 | uint32_t mNewRightVolume; // new volume on right channel |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1546 | uint32_t mStrategy; // strategy for this effect chain |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1547 | // mSuspendedEffects lists all effect currently suspended in the chain |
| 1548 | // use effect type UUID timelow field as key. There is no real risk of identical |
| 1549 | // timeLow fields among effect type UUIDs. |
| 1550 | KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1551 | }; |
| 1552 | |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 1553 | // AudioStreamOut and AudioStreamIn are immutable, so their fields are const. |
| 1554 | // For emphasis, we could also make all pointers to them be "const *", |
| 1555 | // but that would clutter the code unnecessarily. |
| 1556 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1557 | struct AudioStreamOut { |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 1558 | audio_hw_device_t* const hwDev; |
| 1559 | audio_stream_out_t* const stream; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1560 | |
| 1561 | AudioStreamOut(audio_hw_device_t *dev, audio_stream_out_t *out) : |
| 1562 | hwDev(dev), stream(out) {} |
| 1563 | }; |
| 1564 | |
| 1565 | struct AudioStreamIn { |
Glenn Kasten | aed850d | 2012-01-26 09:46:34 -0800 | [diff] [blame] | 1566 | audio_hw_device_t* const hwDev; |
| 1567 | audio_stream_in_t* const stream; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1568 | |
| 1569 | AudioStreamIn(audio_hw_device_t *dev, audio_stream_in_t *in) : |
| 1570 | hwDev(dev), stream(in) {} |
| 1571 | }; |
| 1572 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1573 | // for mAudioSessionRefs only |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1574 | struct AudioSessionRef { |
Glenn Kasten | 012ca6b | 2012-03-06 11:22:01 -0800 | [diff] [blame] | 1575 | AudioSessionRef(int sessionid, pid_t pid) : |
| 1576 | mSessionid(sessionid), mPid(pid), mCnt(1) {} |
| 1577 | const int mSessionid; |
| 1578 | const pid_t mPid; |
| 1579 | int mCnt; |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1580 | }; |
| 1581 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1582 | friend class RecordThread; |
| 1583 | friend class PlaybackThread; |
| 1584 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 1585 | enum master_volume_support { |
| 1586 | // MVS_NONE: |
| 1587 | // Audio HAL has no support for master volume, either setting or |
| 1588 | // getting. All master volume control must be implemented in SW by the |
| 1589 | // AudioFlinger mixing core. |
| 1590 | MVS_NONE, |
| 1591 | |
| 1592 | // MVS_SETONLY: |
| 1593 | // Audio HAL has support for setting master volume, but not for getting |
| 1594 | // master volume (original HAL design did not include a getter). |
| 1595 | // AudioFlinger needs to keep track of the last set master volume in |
| 1596 | // addition to needing to set an initial, default, master volume at HAL |
| 1597 | // load time. |
| 1598 | MVS_SETONLY, |
| 1599 | |
| 1600 | // MVS_FULL: |
| 1601 | // Audio HAL has support both for setting and getting master volume. |
| 1602 | // AudioFlinger should send all set and get master volume requests |
| 1603 | // directly to the HAL. |
| 1604 | MVS_FULL, |
| 1605 | }; |
| 1606 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1607 | mutable Mutex mLock; |
| 1608 | |
Glenn Kasten | 98ec94c | 2012-01-25 14:28:29 -0800 | [diff] [blame] | 1609 | DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client() |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1610 | |
| 1611 | mutable Mutex mHardwareLock; |
Glenn Kasten | 2b213bc | 2012-02-02 14:05:20 -0800 | [diff] [blame] | 1612 | |
| 1613 | // These two fields are immutable after onFirstRef(), so no lock needed to access |
| 1614 | audio_hw_device_t* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1615 | Vector<audio_hw_device_t*> mAudioHwDevs; |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 1616 | |
Glenn Kasten | 8abf44d | 2012-02-02 14:16:03 -0800 | [diff] [blame] | 1617 | // for dump, indicates which hardware operation is currently in progress (but not stream ops) |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 1618 | enum hardware_call_state { |
Glenn Kasten | 8abf44d | 2012-02-02 14:16:03 -0800 | [diff] [blame] | 1619 | AUDIO_HW_IDLE = 0, // no operation in progress |
| 1620 | AUDIO_HW_INIT, // init_check |
| 1621 | AUDIO_HW_OUTPUT_OPEN, // open_output_stream |
| 1622 | AUDIO_HW_OUTPUT_CLOSE, // unused |
| 1623 | AUDIO_HW_INPUT_OPEN, // unused |
| 1624 | AUDIO_HW_INPUT_CLOSE, // unused |
| 1625 | AUDIO_HW_STANDBY, // unused |
| 1626 | AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume |
| 1627 | AUDIO_HW_GET_ROUTING, // unused |
| 1628 | AUDIO_HW_SET_ROUTING, // unused |
| 1629 | AUDIO_HW_GET_MODE, // unused |
| 1630 | AUDIO_HW_SET_MODE, // set_mode |
| 1631 | AUDIO_HW_GET_MIC_MUTE, // get_mic_mute |
| 1632 | AUDIO_HW_SET_MIC_MUTE, // set_mic_mute |
| 1633 | AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume |
| 1634 | AUDIO_HW_SET_PARAMETER, // set_parameters |
| 1635 | AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size |
| 1636 | AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume |
| 1637 | AUDIO_HW_GET_PARAMETER, // get_parameters |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 1638 | }; |
| 1639 | |
Glenn Kasten | a4454b4 | 2012-01-04 11:02:33 -0800 | [diff] [blame] | 1640 | mutable hardware_call_state mHardwareStatus; // for dump only |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1641 | |
| 1642 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1643 | DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads; |
Glenn Kasten | b7bf796 | 2012-02-08 12:36:25 -0800 | [diff] [blame] | 1644 | stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 1645 | |
| 1646 | // both are protected by mLock |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1647 | float mMasterVolume; |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 1648 | float mMasterVolumeSW; |
| 1649 | master_volume_support mMasterVolumeSupportLvl; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1650 | bool mMasterMute; |
| 1651 | |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 1652 | DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1653 | |
| 1654 | DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients; |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1655 | volatile int32_t mNextUniqueId; // updated by android_atomic_inc |
Glenn Kasten | f78aee7 | 2012-01-04 11:00:47 -0800 | [diff] [blame] | 1656 | audio_mode_t mMode; |
Eric Laurent | bee5337 | 2011-08-29 12:42:48 -0700 | [diff] [blame] | 1657 | bool mBtNrecIsOff; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1658 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1659 | // protected by mLock |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1660 | Vector<AudioSessionRef*> mAudioSessionRefs; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 1661 | |
John Grossman | 4ff14ba | 2012-02-08 16:37:41 -0800 | [diff] [blame] | 1662 | float masterVolume_l() const; |
| 1663 | float masterVolumeSW_l() const { return mMasterVolumeSW; } |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 1664 | bool masterMute_l() const { return mMasterMute; } |
Glenn Kasten | 98ec94c | 2012-01-25 14:28:29 -0800 | [diff] [blame] | 1665 | |
| 1666 | private: |
| 1667 | sp<Client> registerPid_l(pid_t pid); // always returns non-0 |
| 1668 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1669 | }; |
| 1670 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1671 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1672 | // ---------------------------------------------------------------------------- |
| 1673 | |
| 1674 | }; // namespace android |
| 1675 | |
| 1676 | #endif // ANDROID_AUDIO_FLINGER_H |