Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1 | /* //device/include/server/AudioFlinger/AudioFlinger.h |
| 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 | |
| 25 | #include <media/IAudioFlinger.h> |
| 26 | #include <media/IAudioFlingerClient.h> |
| 27 | #include <media/IAudioTrack.h> |
| 28 | #include <media/IAudioRecord.h> |
| 29 | #include <media/AudioTrack.h> |
| 30 | |
| 31 | #include <utils/Atomic.h> |
| 32 | #include <utils/Errors.h> |
| 33 | #include <utils/threads.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 34 | #include <utils/SortedVector.h> |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 35 | #include <utils/TypeHelpers.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 36 | #include <utils/Vector.h> |
| 37 | |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 38 | #include <binder/BinderService.h> |
| 39 | #include <binder/MemoryDealer.h> |
| 40 | |
Dima Zavin | 6476024 | 2011-05-11 14:15:23 -0700 | [diff] [blame] | 41 | #include <system/audio.h> |
Dima Zavin | 7394a4f | 2011-06-13 18:16:26 -0700 | [diff] [blame] | 42 | #include <hardware/audio.h> |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 43 | |
| 44 | #include "AudioBufferProvider.h" |
| 45 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 46 | #include <powermanager/IPowerManager.h> |
| 47 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 48 | namespace android { |
| 49 | |
| 50 | class audio_track_cblk_t; |
| 51 | class effect_param_cblk_t; |
| 52 | class AudioMixer; |
| 53 | class AudioBuffer; |
| 54 | class AudioResampler; |
| 55 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 56 | // ---------------------------------------------------------------------------- |
| 57 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 58 | static const nsecs_t kStandbyTimeInNsecs = seconds(3); |
| 59 | |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 60 | class AudioFlinger : |
| 61 | public BinderService<AudioFlinger>, |
| 62 | public BnAudioFlinger |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 63 | { |
Mathias Agopian | 5462fc9 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 64 | friend class BinderService<AudioFlinger>; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 65 | public: |
Glenn Kasten | 54c3b66 | 2012-01-06 07:46:30 -0800 | [diff] [blame] | 66 | static const char* getServiceName() { return "media.audio_flinger"; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 67 | |
| 68 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 69 | |
| 70 | // IAudioFlinger interface |
| 71 | virtual sp<IAudioTrack> createTrack( |
| 72 | pid_t pid, |
| 73 | int streamType, |
| 74 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 75 | uint32_t format, |
| 76 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 77 | int frameCount, |
| 78 | uint32_t flags, |
| 79 | const sp<IMemory>& sharedBuffer, |
| 80 | int output, |
| 81 | int *sessionId, |
| 82 | status_t *status); |
| 83 | |
| 84 | virtual uint32_t sampleRate(int output) const; |
| 85 | virtual int channelCount(int output) const; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 86 | virtual uint32_t format(int output) const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 87 | virtual size_t frameCount(int output) const; |
| 88 | virtual uint32_t latency(int output) const; |
| 89 | |
| 90 | virtual status_t setMasterVolume(float value); |
| 91 | virtual status_t setMasterMute(bool muted); |
| 92 | |
| 93 | virtual float masterVolume() const; |
| 94 | virtual bool masterMute() const; |
| 95 | |
| 96 | virtual status_t setStreamVolume(int stream, float value, int output); |
| 97 | virtual status_t setStreamMute(int stream, bool muted); |
| 98 | |
| 99 | virtual float streamVolume(int stream, int output) const; |
| 100 | virtual bool streamMute(int stream) const; |
| 101 | |
| 102 | virtual status_t setMode(int mode); |
| 103 | |
| 104 | virtual status_t setMicMute(bool state); |
| 105 | virtual bool getMicMute() const; |
| 106 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 107 | virtual status_t setParameters(int ioHandle, const String8& keyValuePairs); |
| 108 | virtual String8 getParameters(int ioHandle, const String8& keys); |
| 109 | |
| 110 | virtual void registerClient(const sp<IAudioFlingerClient>& client); |
| 111 | |
| 112 | virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount); |
| 113 | virtual unsigned int getInputFramesLost(int ioHandle); |
| 114 | |
| 115 | virtual int openOutput(uint32_t *pDevices, |
| 116 | uint32_t *pSamplingRate, |
| 117 | uint32_t *pFormat, |
| 118 | uint32_t *pChannels, |
| 119 | uint32_t *pLatencyMs, |
| 120 | uint32_t flags); |
| 121 | |
| 122 | virtual int openDuplicateOutput(int output1, int output2); |
| 123 | |
| 124 | virtual status_t closeOutput(int output); |
| 125 | |
| 126 | virtual status_t suspendOutput(int output); |
| 127 | |
| 128 | virtual status_t restoreOutput(int output); |
| 129 | |
| 130 | virtual int openInput(uint32_t *pDevices, |
| 131 | uint32_t *pSamplingRate, |
| 132 | uint32_t *pFormat, |
| 133 | uint32_t *pChannels, |
| 134 | uint32_t acoustics); |
| 135 | |
| 136 | virtual status_t closeInput(int input); |
| 137 | |
| 138 | virtual status_t setStreamOutput(uint32_t stream, int output); |
| 139 | |
| 140 | virtual status_t setVoiceVolume(float volume); |
| 141 | |
| 142 | virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output); |
| 143 | |
| 144 | virtual int newAudioSessionId(); |
| 145 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 146 | virtual void acquireAudioSessionId(int audioSession); |
| 147 | |
| 148 | virtual void releaseAudioSessionId(int audioSession); |
| 149 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 150 | virtual status_t queryNumberEffects(uint32_t *numEffects); |
| 151 | |
| 152 | virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor); |
| 153 | |
| 154 | virtual status_t getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor); |
| 155 | |
| 156 | virtual sp<IEffect> createEffect(pid_t pid, |
| 157 | effect_descriptor_t *pDesc, |
| 158 | const sp<IEffectClient>& effectClient, |
| 159 | int32_t priority, |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 160 | int io, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 161 | int sessionId, |
| 162 | status_t *status, |
| 163 | int *id, |
| 164 | int *enabled); |
| 165 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 166 | virtual status_t moveEffects(int sessionId, int srcOutput, int dstOutput); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 167 | |
| 168 | enum hardware_call_state { |
| 169 | AUDIO_HW_IDLE = 0, |
| 170 | AUDIO_HW_INIT, |
| 171 | AUDIO_HW_OUTPUT_OPEN, |
| 172 | AUDIO_HW_OUTPUT_CLOSE, |
| 173 | AUDIO_HW_INPUT_OPEN, |
| 174 | AUDIO_HW_INPUT_CLOSE, |
| 175 | AUDIO_HW_STANDBY, |
| 176 | AUDIO_HW_SET_MASTER_VOLUME, |
| 177 | AUDIO_HW_GET_ROUTING, |
| 178 | AUDIO_HW_SET_ROUTING, |
| 179 | AUDIO_HW_GET_MODE, |
| 180 | AUDIO_HW_SET_MODE, |
| 181 | AUDIO_HW_GET_MIC_MUTE, |
| 182 | AUDIO_HW_SET_MIC_MUTE, |
| 183 | AUDIO_SET_VOICE_VOLUME, |
| 184 | AUDIO_SET_PARAMETER, |
| 185 | }; |
| 186 | |
| 187 | // record interface |
| 188 | virtual sp<IAudioRecord> openRecord( |
| 189 | pid_t pid, |
| 190 | int input, |
| 191 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 192 | uint32_t format, |
| 193 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 194 | int frameCount, |
| 195 | uint32_t flags, |
| 196 | int *sessionId, |
| 197 | status_t *status); |
| 198 | |
| 199 | virtual status_t onTransact( |
| 200 | uint32_t code, |
| 201 | const Parcel& data, |
| 202 | Parcel* reply, |
| 203 | uint32_t flags); |
| 204 | |
| 205 | uint32_t getMode() { return mMode; } |
| 206 | |
Eric Laurent | bee5337 | 2011-08-29 12:42:48 -0700 | [diff] [blame] | 207 | bool btNrecIsOff() { return mBtNrecIsOff; } |
Eric Laurent | 59bd0da | 2011-08-01 09:52:20 -0700 | [diff] [blame] | 208 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 209 | private: |
| 210 | AudioFlinger(); |
| 211 | virtual ~AudioFlinger(); |
| 212 | |
Dima Zavin | 5a61d2f | 2011-04-19 19:04:32 -0700 | [diff] [blame] | 213 | status_t initCheck() const; |
| 214 | virtual void onFirstRef(); |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 215 | audio_hw_device_t* findSuitableHwDev_l(uint32_t devices); |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 216 | void purgeStaleEffects_l(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 217 | |
| 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(); |
| 228 | const sp<MemoryDealer>& heap() const; |
| 229 | pid_t pid() const { return mPid; } |
| 230 | sp<AudioFlinger> audioFlinger() { return mAudioFlinger; } |
| 231 | |
| 232 | private: |
| 233 | Client(const Client&); |
| 234 | Client& operator = (const Client&); |
| 235 | sp<AudioFlinger> mAudioFlinger; |
| 236 | sp<MemoryDealer> mMemoryDealer; |
| 237 | pid_t mPid; |
| 238 | }; |
| 239 | |
| 240 | // --- Notification Client --- |
| 241 | class NotificationClient : public IBinder::DeathRecipient { |
| 242 | public: |
| 243 | NotificationClient(const sp<AudioFlinger>& audioFlinger, |
| 244 | const sp<IAudioFlingerClient>& client, |
| 245 | pid_t pid); |
| 246 | virtual ~NotificationClient(); |
| 247 | |
| 248 | sp<IAudioFlingerClient> client() { return mClient; } |
| 249 | |
| 250 | // IBinder::DeathRecipient |
| 251 | virtual void binderDied(const wp<IBinder>& who); |
| 252 | |
| 253 | private: |
| 254 | NotificationClient(const NotificationClient&); |
| 255 | NotificationClient& operator = (const NotificationClient&); |
| 256 | |
| 257 | sp<AudioFlinger> mAudioFlinger; |
| 258 | pid_t mPid; |
| 259 | sp<IAudioFlingerClient> mClient; |
| 260 | }; |
| 261 | |
| 262 | class TrackHandle; |
| 263 | class RecordHandle; |
| 264 | class RecordThread; |
| 265 | class PlaybackThread; |
| 266 | class MixerThread; |
| 267 | class DirectOutputThread; |
| 268 | class DuplicatingThread; |
| 269 | class Track; |
| 270 | class RecordTrack; |
| 271 | class EffectModule; |
| 272 | class EffectHandle; |
| 273 | class EffectChain; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 274 | struct AudioStreamOut; |
| 275 | struct AudioStreamIn; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 276 | |
| 277 | class ThreadBase : public Thread { |
| 278 | public: |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 279 | ThreadBase (const sp<AudioFlinger>& audioFlinger, int id, uint32_t device); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 280 | virtual ~ThreadBase(); |
| 281 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 282 | |
| 283 | enum type { |
| 284 | MIXER, // Thread class is MixerThread |
| 285 | DIRECT, // Thread class is DirectOutputThread |
| 286 | DUPLICATING, // Thread class is DuplicatingThread |
| 287 | RECORD // Thread class is RecordThread |
| 288 | }; |
| 289 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 290 | status_t dumpBase(int fd, const Vector<String16>& args); |
Eric Laurent | 1d2bff0 | 2011-07-24 17:49:51 -0700 | [diff] [blame] | 291 | status_t dumpEffectChains(int fd, const Vector<String16>& args); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 292 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 293 | void clearPowerManager(); |
| 294 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 295 | // base for record and playback |
| 296 | class TrackBase : public AudioBufferProvider, public RefBase { |
| 297 | |
| 298 | public: |
| 299 | enum track_state { |
| 300 | IDLE, |
| 301 | TERMINATED, |
| 302 | STOPPED, |
| 303 | RESUMING, |
| 304 | ACTIVE, |
| 305 | PAUSING, |
| 306 | PAUSED |
| 307 | }; |
| 308 | |
| 309 | enum track_flags { |
| 310 | STEPSERVER_FAILED = 0x01, // StepServer could not acquire cblk->lock mutex |
| 311 | SYSTEM_FLAGS_MASK = 0x0000ffffUL, |
| 312 | // The upper 16 bits are used for track-specific flags. |
| 313 | }; |
| 314 | |
| 315 | TrackBase(const wp<ThreadBase>& thread, |
| 316 | const sp<Client>& client, |
| 317 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 318 | uint32_t format, |
| 319 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 320 | int frameCount, |
| 321 | uint32_t flags, |
| 322 | const sp<IMemory>& sharedBuffer, |
| 323 | int sessionId); |
| 324 | ~TrackBase(); |
| 325 | |
| 326 | virtual status_t start() = 0; |
| 327 | virtual void stop() = 0; |
| 328 | sp<IMemory> getCblk() const; |
| 329 | audio_track_cblk_t* cblk() const { return mCblk; } |
| 330 | int sessionId() { return mSessionId; } |
| 331 | |
| 332 | protected: |
| 333 | friend class ThreadBase; |
| 334 | friend class RecordHandle; |
| 335 | friend class PlaybackThread; |
| 336 | friend class RecordThread; |
| 337 | friend class MixerThread; |
| 338 | friend class DirectOutputThread; |
| 339 | |
| 340 | TrackBase(const TrackBase&); |
| 341 | TrackBase& operator = (const TrackBase&); |
| 342 | |
| 343 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0; |
| 344 | virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); |
| 345 | |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 346 | uint32_t format() const { |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 347 | return mFormat; |
| 348 | } |
| 349 | |
| 350 | int channelCount() const ; |
| 351 | |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 352 | uint32_t channelMask() const; |
| 353 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 354 | int sampleRate() const; |
| 355 | |
| 356 | void* getBuffer(uint32_t offset, uint32_t frames) const; |
| 357 | |
| 358 | bool isStopped() const { |
| 359 | return mState == STOPPED; |
| 360 | } |
| 361 | |
| 362 | bool isTerminated() const { |
| 363 | return mState == TERMINATED; |
| 364 | } |
| 365 | |
| 366 | bool step(); |
| 367 | void reset(); |
| 368 | |
| 369 | wp<ThreadBase> mThread; |
| 370 | sp<Client> mClient; |
| 371 | sp<IMemory> mCblkMemory; |
| 372 | audio_track_cblk_t* mCblk; |
| 373 | void* mBuffer; |
| 374 | void* mBufferEnd; |
| 375 | uint32_t mFrameCount; |
| 376 | // we don't really need a lock for these |
| 377 | int mState; |
| 378 | int mClientTid; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 379 | uint32_t mFormat; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 380 | uint32_t mFlags; |
| 381 | int mSessionId; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 382 | uint8_t mChannelCount; |
| 383 | uint32_t mChannelMask; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 384 | }; |
| 385 | |
| 386 | class ConfigEvent { |
| 387 | public: |
| 388 | ConfigEvent() : mEvent(0), mParam(0) {} |
| 389 | |
| 390 | int mEvent; |
| 391 | int mParam; |
| 392 | }; |
| 393 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 394 | class PMDeathRecipient : public IBinder::DeathRecipient { |
| 395 | public: |
| 396 | PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} |
| 397 | virtual ~PMDeathRecipient() {} |
| 398 | |
| 399 | // IBinder::DeathRecipient |
| 400 | virtual void binderDied(const wp<IBinder>& who); |
| 401 | |
| 402 | private: |
| 403 | PMDeathRecipient(const PMDeathRecipient&); |
| 404 | PMDeathRecipient& operator = (const PMDeathRecipient&); |
| 405 | |
| 406 | wp<ThreadBase> mThread; |
| 407 | }; |
| 408 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 409 | virtual status_t initCheck() const = 0; |
| 410 | int type() const { return mType; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 411 | uint32_t sampleRate() const; |
| 412 | int channelCount() const; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 413 | uint32_t format() const; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 414 | size_t frameCount() const; |
| 415 | void wakeUp() { mWaitWorkCV.broadcast(); } |
| 416 | void exit(); |
| 417 | virtual bool checkForNewParameters_l() = 0; |
| 418 | virtual status_t setParameters(const String8& keyValuePairs); |
| 419 | virtual String8 getParameters(const String8& keys) = 0; |
| 420 | virtual void audioConfigChanged_l(int event, int param = 0) = 0; |
| 421 | void sendConfigEvent(int event, int param = 0); |
| 422 | void sendConfigEvent_l(int event, int param = 0); |
| 423 | void processConfigEvents(); |
| 424 | int id() const { return mId;} |
| 425 | bool standby() { return mStandby; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 426 | uint32_t device() { return mDevice; } |
| 427 | virtual audio_stream_t* stream() = 0; |
| 428 | |
| 429 | sp<EffectHandle> createEffect_l( |
| 430 | const sp<AudioFlinger::Client>& client, |
| 431 | const sp<IEffectClient>& effectClient, |
| 432 | int32_t priority, |
| 433 | int sessionId, |
| 434 | effect_descriptor_t *desc, |
| 435 | int *enabled, |
| 436 | status_t *status); |
| 437 | void disconnectEffect(const sp< EffectModule>& effect, |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 438 | const wp<EffectHandle>& handle, |
| 439 | bool unpiniflast); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 440 | |
| 441 | // return values for hasAudioSession (bit field) |
| 442 | enum effect_state { |
| 443 | EFFECT_SESSION = 0x1, // the audio session corresponds to at least one |
| 444 | // effect |
| 445 | TRACK_SESSION = 0x2 // the audio session corresponds to at least one |
| 446 | // track |
| 447 | }; |
| 448 | |
| 449 | // get effect chain corresponding to session Id. |
| 450 | sp<EffectChain> getEffectChain(int sessionId); |
| 451 | // same as getEffectChain() but must be called with ThreadBase mutex locked |
| 452 | sp<EffectChain> getEffectChain_l(int sessionId); |
| 453 | // add an effect chain to the chain list (mEffectChains) |
| 454 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; |
| 455 | // remove an effect chain from the chain list (mEffectChains) |
| 456 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; |
| 457 | // lock mall effect chains Mutexes. Must be called before releasing the |
| 458 | // ThreadBase mutex before processing the mixer and effects. This guarantees the |
| 459 | // integrity of the chains during the process. |
| 460 | void lockEffectChains_l(Vector<sp <EffectChain> >& effectChains); |
| 461 | // unlock effect chains after process |
| 462 | void unlockEffectChains(Vector<sp <EffectChain> >& effectChains); |
| 463 | // set audio mode to all effect chains |
| 464 | void setMode(uint32_t mode); |
| 465 | // get effect module with corresponding ID on specified audio session |
| 466 | sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId); |
| 467 | // add and effect module. Also creates the effect chain is none exists for |
| 468 | // the effects audio session |
| 469 | status_t addEffect_l(const sp< EffectModule>& effect); |
| 470 | // remove and effect module. Also removes the effect chain is this was the last |
| 471 | // effect |
| 472 | void removeEffect_l(const sp< EffectModule>& effect); |
| 473 | // detach all tracks connected to an auxiliary effect |
| 474 | virtual void detachAuxEffect_l(int effectId) {} |
| 475 | // returns either EFFECT_SESSION if effects on this audio session exist in one |
| 476 | // chain, or TRACK_SESSION if tracks on this audio session exist, or both |
| 477 | virtual uint32_t hasAudioSession(int sessionId) = 0; |
| 478 | // the value returned by default implementation is not important as the |
| 479 | // strategy is only meaningful for PlaybackThread which implements this method |
| 480 | virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 481 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 482 | // suspend or restore effect according to the type of effect passed. a NULL |
| 483 | // type pointer means suspend all effects in the session |
| 484 | void setEffectSuspended(const effect_uuid_t *type, |
| 485 | bool suspend, |
| 486 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
| 487 | // check if some effects must be suspended/restored when an effect is enabled |
| 488 | // or disabled |
Eric Laurent | a85a74a | 2011-10-19 11:44:54 -0700 | [diff] [blame] | 489 | void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 490 | bool enabled, |
| 491 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
Eric Laurent | a85a74a | 2011-10-19 11:44:54 -0700 | [diff] [blame] | 492 | void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, |
| 493 | bool enabled, |
| 494 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 495 | mutable Mutex mLock; |
| 496 | |
| 497 | protected: |
| 498 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 499 | // entry describing an effect being suspended in mSuspendedSessions keyed vector |
| 500 | class SuspendedSessionDesc : public RefBase { |
| 501 | public: |
| 502 | SuspendedSessionDesc() : mRefCount(0) {} |
| 503 | |
| 504 | int mRefCount; // number of active suspend requests |
| 505 | effect_uuid_t mType; // effect type UUID |
| 506 | }; |
| 507 | |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 508 | void acquireWakeLock(); |
| 509 | void acquireWakeLock_l(); |
| 510 | void releaseWakeLock(); |
| 511 | void releaseWakeLock_l(); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 512 | void setEffectSuspended_l(const effect_uuid_t *type, |
| 513 | bool suspend, |
| 514 | int sessionId = AUDIO_SESSION_OUTPUT_MIX); |
| 515 | // updated mSuspendedSessions when an effect suspended or restored |
| 516 | void updateSuspendedSessions_l(const effect_uuid_t *type, |
| 517 | bool suspend, |
| 518 | int sessionId); |
| 519 | // check if some effects must be suspended when an effect chain is added |
| 520 | void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 521 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 522 | friend class AudioFlinger; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 523 | friend class Track; |
| 524 | friend class TrackBase; |
| 525 | friend class PlaybackThread; |
| 526 | friend class MixerThread; |
| 527 | friend class DirectOutputThread; |
| 528 | friend class DuplicatingThread; |
| 529 | friend class RecordThread; |
| 530 | friend class RecordTrack; |
| 531 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 532 | int mType; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 533 | Condition mWaitWorkCV; |
| 534 | sp<AudioFlinger> mAudioFlinger; |
| 535 | uint32_t mSampleRate; |
| 536 | size_t mFrameCount; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 537 | uint32_t mChannelMask; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 538 | uint16_t mChannelCount; |
| 539 | uint16_t mFrameSize; |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 540 | uint32_t mFormat; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 541 | Condition mParamCond; |
| 542 | Vector<String8> mNewParameters; |
| 543 | status_t mParamStatus; |
Glenn Kasten | f3990f2 | 2011-12-13 11:50:00 -0800 | [diff] [blame] | 544 | Vector<ConfigEvent> mConfigEvents; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 545 | bool mStandby; |
| 546 | int mId; |
| 547 | bool mExiting; |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 548 | Vector< sp<EffectChain> > mEffectChains; |
| 549 | uint32_t mDevice; // output device for PlaybackThread |
| 550 | // input + output devices for RecordThread |
Eric Laurent | feb0db6 | 2011-07-22 09:04:31 -0700 | [diff] [blame] | 551 | static const int kNameLength = 32; |
| 552 | char mName[kNameLength]; |
| 553 | sp<IPowerManager> mPowerManager; |
| 554 | sp<IBinder> mWakeLockToken; |
| 555 | sp<PMDeathRecipient> mDeathRecipient; |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 556 | // list of suspended effects per session and per type. The first vector is |
| 557 | // keyed by session ID, the second by type UUID timeLow field |
| 558 | KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 559 | }; |
| 560 | |
| 561 | // --- PlaybackThread --- |
| 562 | class PlaybackThread : public ThreadBase { |
| 563 | public: |
| 564 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 565 | enum mixer_state { |
| 566 | MIXER_IDLE, |
| 567 | MIXER_TRACKS_ENABLED, |
| 568 | MIXER_TRACKS_READY |
| 569 | }; |
| 570 | |
| 571 | // playback track |
| 572 | class Track : public TrackBase { |
| 573 | public: |
| 574 | Track( const wp<ThreadBase>& thread, |
| 575 | const sp<Client>& client, |
| 576 | int streamType, |
| 577 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 578 | uint32_t format, |
| 579 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 580 | int frameCount, |
| 581 | const sp<IMemory>& sharedBuffer, |
| 582 | int sessionId); |
| 583 | ~Track(); |
| 584 | |
| 585 | void dump(char* buffer, size_t size); |
| 586 | virtual status_t start(); |
| 587 | virtual void stop(); |
| 588 | void pause(); |
| 589 | |
| 590 | void flush(); |
| 591 | void destroy(); |
| 592 | void mute(bool); |
| 593 | void setVolume(float left, float right); |
| 594 | int name() const { |
| 595 | return mName; |
| 596 | } |
| 597 | |
| 598 | int type() const { |
| 599 | return mStreamType; |
| 600 | } |
| 601 | status_t attachAuxEffect(int EffectId); |
| 602 | void setAuxBuffer(int EffectId, int32_t *buffer); |
| 603 | int32_t *auxBuffer() { return mAuxBuffer; } |
| 604 | void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; } |
| 605 | int16_t *mainBuffer() { return mMainBuffer; } |
| 606 | int auxEffectId() { return mAuxEffectId; } |
| 607 | |
| 608 | |
| 609 | protected: |
| 610 | friend class ThreadBase; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 611 | friend class TrackHandle; |
| 612 | friend class PlaybackThread; |
| 613 | friend class MixerThread; |
| 614 | friend class DirectOutputThread; |
| 615 | |
| 616 | Track(const Track&); |
| 617 | Track& operator = (const Track&); |
| 618 | |
| 619 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); |
| 620 | bool isMuted() { return mMute; } |
| 621 | bool isPausing() const { |
| 622 | return mState == PAUSING; |
| 623 | } |
| 624 | bool isPaused() const { |
| 625 | return mState == PAUSED; |
| 626 | } |
| 627 | bool isReady() const; |
| 628 | void setPaused() { mState = PAUSED; } |
| 629 | void reset(); |
| 630 | |
| 631 | bool isOutputTrack() const { |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 632 | return (mStreamType == AUDIO_STREAM_CNT); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 633 | } |
| 634 | |
| 635 | // we don't really need a lock for these |
| 636 | float mVolume[2]; |
| 637 | volatile bool mMute; |
| 638 | // FILLED state is used for suppressing volume ramp at begin of playing |
| 639 | enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; |
| 640 | mutable uint8_t mFillingUpStatus; |
| 641 | int8_t mRetryCount; |
| 642 | sp<IMemory> mSharedBuffer; |
| 643 | bool mResetDone; |
| 644 | int mStreamType; |
| 645 | int mName; |
| 646 | int16_t *mMainBuffer; |
| 647 | int32_t *mAuxBuffer; |
| 648 | int mAuxEffectId; |
Eric Laurent | 8f45bd7 | 2010-08-31 13:50:07 -0700 | [diff] [blame] | 649 | bool mHasVolumeController; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 650 | }; // end of Track |
| 651 | |
| 652 | |
| 653 | // playback track |
| 654 | class OutputTrack : public Track { |
| 655 | public: |
| 656 | |
| 657 | class Buffer: public AudioBufferProvider::Buffer { |
| 658 | public: |
| 659 | int16_t *mBuffer; |
| 660 | }; |
| 661 | |
| 662 | OutputTrack( const wp<ThreadBase>& thread, |
| 663 | DuplicatingThread *sourceThread, |
| 664 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 665 | uint32_t format, |
| 666 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 667 | int frameCount); |
| 668 | ~OutputTrack(); |
| 669 | |
| 670 | virtual status_t start(); |
| 671 | virtual void stop(); |
| 672 | bool write(int16_t* data, uint32_t frames); |
| 673 | bool bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; } |
| 674 | bool isActive() { return mActive; } |
| 675 | wp<ThreadBase>& thread() { return mThread; } |
| 676 | |
| 677 | private: |
| 678 | |
| 679 | status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs); |
| 680 | void clearBufferQueue(); |
| 681 | |
| 682 | // Maximum number of pending buffers allocated by OutputTrack::write() |
| 683 | static const uint8_t kMaxOverFlowBuffers = 10; |
| 684 | |
| 685 | Vector < Buffer* > mBufferQueue; |
| 686 | AudioBufferProvider::Buffer mOutBuffer; |
| 687 | bool mActive; |
| 688 | DuplicatingThread* mSourceThread; |
| 689 | }; // end of OutputTrack |
| 690 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 691 | PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 692 | virtual ~PlaybackThread(); |
| 693 | |
| 694 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 695 | |
| 696 | // Thread virtuals |
| 697 | virtual status_t readyToRun(); |
| 698 | virtual void onFirstRef(); |
| 699 | |
Glenn Kasten | e0feee3 | 2011-12-13 11:53:26 -0800 | [diff] [blame] | 700 | virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 701 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 702 | virtual uint32_t latency() const; |
| 703 | |
| 704 | virtual status_t setMasterVolume(float value); |
| 705 | virtual status_t setMasterMute(bool muted); |
| 706 | |
| 707 | virtual float masterVolume() const; |
| 708 | virtual bool masterMute() const; |
| 709 | |
| 710 | virtual status_t setStreamVolume(int stream, float value); |
| 711 | virtual status_t setStreamMute(int stream, bool muted); |
| 712 | |
| 713 | virtual float streamVolume(int stream) const; |
| 714 | virtual bool streamMute(int stream) const; |
| 715 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 716 | sp<Track> createTrack_l( |
| 717 | const sp<AudioFlinger::Client>& client, |
| 718 | int streamType, |
| 719 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 720 | uint32_t format, |
| 721 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 722 | int frameCount, |
| 723 | const sp<IMemory>& sharedBuffer, |
| 724 | int sessionId, |
| 725 | status_t *status); |
| 726 | |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 727 | AudioStreamOut* getOutput(); |
| 728 | AudioStreamOut* clearOutput(); |
| 729 | virtual audio_stream_t* stream(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 730 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 731 | void suspend() { mSuspended++; } |
| 732 | void restore() { if (mSuspended) mSuspended--; } |
Glenn Kasten | a3a8548 | 2012-01-04 11:01:11 -0800 | [diff] [blame] | 733 | bool isSuspended() const { return (mSuspended != 0); } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 734 | virtual String8 getParameters(const String8& keys); |
| 735 | virtual void audioConfigChanged_l(int event, int param = 0); |
| 736 | virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); |
| 737 | int16_t *mixBuffer() { return mMixBuffer; }; |
| 738 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 739 | virtual void detachAuxEffect_l(int effectId); |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 740 | status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, |
| 741 | int EffectId); |
| 742 | status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, |
| 743 | int EffectId); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 744 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 745 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain); |
| 746 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); |
| 747 | virtual uint32_t hasAudioSession(int sessionId); |
| 748 | virtual uint32_t getStrategyForSession_l(int sessionId); |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 749 | |
Eric Laurent | 9f6530f | 2011-08-30 10:18:54 -0700 | [diff] [blame] | 750 | void setStreamValid(int streamType, bool valid); |
| 751 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 752 | struct stream_type_t { |
| 753 | stream_type_t() |
| 754 | : volume(1.0f), |
Eric Laurent | 9f6530f | 2011-08-30 10:18:54 -0700 | [diff] [blame] | 755 | mute(false), |
| 756 | valid(true) |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 757 | { |
| 758 | } |
| 759 | float volume; |
| 760 | bool mute; |
Eric Laurent | 9f6530f | 2011-08-30 10:18:54 -0700 | [diff] [blame] | 761 | bool valid; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 762 | }; |
| 763 | |
| 764 | protected: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 765 | int16_t* mMixBuffer; |
| 766 | int mSuspended; |
| 767 | int mBytesWritten; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame^] | 768 | private: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 769 | bool mMasterMute; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame^] | 770 | protected: |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 771 | SortedVector< wp<Track> > mActiveTracks; |
| 772 | |
| 773 | virtual int getTrackName_l() = 0; |
| 774 | virtual void deleteTrackName_l(int name) = 0; |
Eric Laurent | 162b40b | 2011-12-05 09:47:19 -0800 | [diff] [blame] | 775 | virtual uint32_t activeSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 776 | virtual uint32_t idleSleepTimeUs() = 0; |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 777 | virtual uint32_t suspendSleepTimeUs() = 0; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 778 | |
| 779 | private: |
| 780 | |
| 781 | friend class AudioFlinger; |
| 782 | friend class OutputTrack; |
| 783 | friend class Track; |
| 784 | friend class TrackBase; |
| 785 | friend class MixerThread; |
| 786 | friend class DirectOutputThread; |
| 787 | friend class DuplicatingThread; |
| 788 | |
| 789 | PlaybackThread(const Client&); |
| 790 | PlaybackThread& operator = (const PlaybackThread&); |
| 791 | |
| 792 | status_t addTrack_l(const sp<Track>& track); |
| 793 | void destroyTrack_l(const sp<Track>& track); |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 794 | void removeTrack_l(const sp<Track>& track); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 795 | |
| 796 | void readOutputParameters(); |
| 797 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 798 | virtual status_t dumpInternals(int fd, const Vector<String16>& args); |
| 799 | status_t dumpTracks(int fd, const Vector<String16>& args); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 800 | |
| 801 | SortedVector< sp<Track> > mTracks; |
| 802 | // mStreamTypes[] uses 1 additionnal stream type internally for the OutputTrack used by DuplicatingThread |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 803 | stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1]; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 804 | AudioStreamOut* mOutput; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 805 | float mMasterVolume; |
| 806 | nsecs_t mLastWriteTime; |
| 807 | int mNumWrites; |
| 808 | int mNumDelayedWrites; |
| 809 | bool mInWrite; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 810 | }; |
| 811 | |
| 812 | class MixerThread : public PlaybackThread { |
| 813 | public: |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 814 | MixerThread (const sp<AudioFlinger>& audioFlinger, |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 815 | AudioStreamOut* output, |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 816 | int id, |
| 817 | uint32_t device); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 818 | virtual ~MixerThread(); |
| 819 | |
| 820 | // Thread virtuals |
| 821 | virtual bool threadLoop(); |
| 822 | |
| 823 | void invalidateTracks(int streamType); |
| 824 | virtual bool checkForNewParameters_l(); |
| 825 | virtual status_t dumpInternals(int fd, const Vector<String16>& args); |
| 826 | |
| 827 | protected: |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 828 | uint32_t prepareTracks_l(const SortedVector< wp<Track> >& activeTracks, |
| 829 | Vector< sp<Track> > *tracksToRemove); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 830 | virtual int getTrackName_l(); |
| 831 | virtual void deleteTrackName_l(int name); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 832 | virtual uint32_t idleSleepTimeUs(); |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 833 | virtual uint32_t suspendSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 834 | |
| 835 | AudioMixer* mAudioMixer; |
| 836 | }; |
| 837 | |
| 838 | class DirectOutputThread : public PlaybackThread { |
| 839 | public: |
| 840 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 841 | DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 842 | ~DirectOutputThread(); |
| 843 | |
| 844 | // Thread virtuals |
| 845 | virtual bool threadLoop(); |
| 846 | |
| 847 | virtual bool checkForNewParameters_l(); |
| 848 | |
| 849 | protected: |
| 850 | virtual int getTrackName_l(); |
| 851 | virtual void deleteTrackName_l(int name); |
| 852 | virtual uint32_t activeSleepTimeUs(); |
| 853 | virtual uint32_t idleSleepTimeUs(); |
Eric Laurent | 25cbe0e | 2010-08-18 18:13:17 -0700 | [diff] [blame] | 854 | virtual uint32_t suspendSleepTimeUs(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 855 | |
| 856 | private: |
| 857 | void applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp); |
| 858 | |
| 859 | float mLeftVolFloat; |
| 860 | float mRightVolFloat; |
| 861 | uint16_t mLeftVolShort; |
| 862 | uint16_t mRightVolShort; |
| 863 | }; |
| 864 | |
| 865 | class DuplicatingThread : public MixerThread { |
| 866 | public: |
| 867 | DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, int id); |
| 868 | ~DuplicatingThread(); |
| 869 | |
| 870 | // Thread virtuals |
| 871 | virtual bool threadLoop(); |
| 872 | void addOutputTrack(MixerThread* thread); |
| 873 | void removeOutputTrack(MixerThread* thread); |
| 874 | uint32_t waitTimeMs() { return mWaitTimeMs; } |
| 875 | protected: |
| 876 | virtual uint32_t activeSleepTimeUs(); |
| 877 | |
| 878 | private: |
| 879 | bool outputsReady(SortedVector< sp<OutputTrack> > &outputTracks); |
| 880 | void updateWaitTime(); |
| 881 | |
| 882 | SortedVector < sp<OutputTrack> > mOutputTracks; |
| 883 | uint32_t mWaitTimeMs; |
| 884 | }; |
| 885 | |
| 886 | PlaybackThread *checkPlaybackThread_l(int output) const; |
| 887 | MixerThread *checkMixerThread_l(int output) const; |
| 888 | RecordThread *checkRecordThread_l(int input) const; |
| 889 | float streamVolumeInternal(int stream) const { return mStreamTypes[stream].volume; } |
| 890 | void audioConfigChanged_l(int event, int ioHandle, void *param2); |
| 891 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 892 | uint32_t nextUniqueId(); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 893 | status_t moveEffectChain_l(int sessionId, |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 894 | AudioFlinger::PlaybackThread *srcThread, |
Eric Laurent | 39e94f8 | 2010-07-28 01:32:47 -0700 | [diff] [blame] | 895 | AudioFlinger::PlaybackThread *dstThread, |
| 896 | bool reRegister); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 897 | PlaybackThread *primaryPlaybackThread_l(); |
| 898 | uint32_t primaryOutputDevice_l(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 899 | |
| 900 | friend class AudioBuffer; |
| 901 | |
| 902 | class TrackHandle : public android::BnAudioTrack { |
| 903 | public: |
| 904 | TrackHandle(const sp<PlaybackThread::Track>& track); |
| 905 | virtual ~TrackHandle(); |
| 906 | virtual status_t start(); |
| 907 | virtual void stop(); |
| 908 | virtual void flush(); |
| 909 | virtual void mute(bool); |
| 910 | virtual void pause(); |
| 911 | virtual void setVolume(float left, float right); |
| 912 | virtual sp<IMemory> getCblk() const; |
| 913 | virtual status_t attachAuxEffect(int effectId); |
| 914 | virtual status_t onTransact( |
| 915 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 916 | private: |
| 917 | sp<PlaybackThread::Track> mTrack; |
| 918 | }; |
| 919 | |
| 920 | friend class Client; |
| 921 | friend class PlaybackThread::Track; |
| 922 | |
| 923 | |
| 924 | void removeClient_l(pid_t pid); |
| 925 | void removeNotificationClient(pid_t pid); |
| 926 | |
| 927 | |
| 928 | // record thread |
| 929 | class RecordThread : public ThreadBase, public AudioBufferProvider |
| 930 | { |
| 931 | public: |
| 932 | |
| 933 | // record track |
| 934 | class RecordTrack : public TrackBase { |
| 935 | public: |
| 936 | RecordTrack(const wp<ThreadBase>& thread, |
| 937 | const sp<Client>& client, |
| 938 | uint32_t sampleRate, |
Jean-Michel Trivi | 0d255b2 | 2011-05-24 15:53:33 -0700 | [diff] [blame] | 939 | uint32_t format, |
| 940 | uint32_t channelMask, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 941 | int frameCount, |
| 942 | uint32_t flags, |
| 943 | int sessionId); |
| 944 | ~RecordTrack(); |
| 945 | |
| 946 | virtual status_t start(); |
| 947 | virtual void stop(); |
| 948 | |
| 949 | bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; } |
| 950 | bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; } |
| 951 | |
| 952 | void dump(char* buffer, size_t size); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 953 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 954 | private: |
| 955 | friend class AudioFlinger; |
| 956 | friend class RecordThread; |
| 957 | |
| 958 | RecordTrack(const RecordTrack&); |
| 959 | RecordTrack& operator = (const RecordTrack&); |
| 960 | |
| 961 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); |
| 962 | |
| 963 | bool mOverflow; |
| 964 | }; |
| 965 | |
| 966 | |
| 967 | RecordThread(const sp<AudioFlinger>& audioFlinger, |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 968 | AudioStreamIn *input, |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 969 | uint32_t sampleRate, |
| 970 | uint32_t channels, |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 971 | int id, |
| 972 | uint32_t device); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 973 | ~RecordThread(); |
| 974 | |
| 975 | virtual bool threadLoop(); |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 976 | virtual status_t readyToRun(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 977 | virtual void onFirstRef(); |
| 978 | |
Glenn Kasten | e0feee3 | 2011-12-13 11:53:26 -0800 | [diff] [blame] | 979 | virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 980 | sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( |
| 981 | const sp<AudioFlinger::Client>& client, |
| 982 | uint32_t sampleRate, |
| 983 | int format, |
| 984 | int channelMask, |
| 985 | int frameCount, |
| 986 | uint32_t flags, |
| 987 | int sessionId, |
| 988 | status_t *status); |
| 989 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 990 | status_t start(RecordTrack* recordTrack); |
| 991 | void stop(RecordTrack* recordTrack); |
| 992 | status_t dump(int fd, const Vector<String16>& args); |
Eric Laurent | b8ba0a9 | 2011-08-07 16:32:26 -0700 | [diff] [blame] | 993 | AudioStreamIn* getInput(); |
| 994 | AudioStreamIn* clearInput(); |
| 995 | virtual audio_stream_t* stream(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 996 | |
| 997 | virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); |
| 998 | virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); |
| 999 | virtual bool checkForNewParameters_l(); |
| 1000 | virtual String8 getParameters(const String8& keys); |
| 1001 | virtual void audioConfigChanged_l(int event, int param = 0); |
| 1002 | void readInputParameters(); |
| 1003 | virtual unsigned int getInputFramesLost(); |
| 1004 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1005 | virtual status_t addEffectChain_l(const sp<EffectChain>& chain); |
| 1006 | virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); |
| 1007 | virtual uint32_t hasAudioSession(int sessionId); |
Eric Laurent | 59bd0da | 2011-08-01 09:52:20 -0700 | [diff] [blame] | 1008 | RecordTrack* track(); |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1009 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1010 | private: |
| 1011 | RecordThread(); |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1012 | AudioStreamIn *mInput; |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1013 | RecordTrack* mTrack; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1014 | sp<RecordTrack> mActiveTrack; |
| 1015 | Condition mStartStopCond; |
| 1016 | AudioResampler *mResampler; |
| 1017 | int32_t *mRsmpOutBuffer; |
| 1018 | int16_t *mRsmpInBuffer; |
| 1019 | size_t mRsmpInIndex; |
| 1020 | size_t mInputBytes; |
| 1021 | int mReqChannelCount; |
| 1022 | uint32_t mReqSampleRate; |
| 1023 | ssize_t mBytesRead; |
| 1024 | }; |
| 1025 | |
| 1026 | class RecordHandle : public android::BnAudioRecord { |
| 1027 | public: |
| 1028 | RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); |
| 1029 | virtual ~RecordHandle(); |
| 1030 | virtual status_t start(); |
| 1031 | virtual void stop(); |
| 1032 | virtual sp<IMemory> getCblk() const; |
| 1033 | virtual status_t onTransact( |
| 1034 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 1035 | private: |
| 1036 | sp<RecordThread::RecordTrack> mRecordTrack; |
| 1037 | }; |
| 1038 | |
| 1039 | //--- Audio Effect Management |
| 1040 | |
| 1041 | // EffectModule and EffectChain classes both have their own mutex to protect |
| 1042 | // state changes or resource modifications. Always respect the following order |
| 1043 | // if multiple mutexes must be acquired to avoid cross deadlock: |
| 1044 | // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule |
| 1045 | |
| 1046 | // The EffectModule class is a wrapper object controlling the effect engine implementation |
| 1047 | // in the effect library. It prevents concurrent calls to process() and command() functions |
| 1048 | // from different client threads. It keeps a list of EffectHandle objects corresponding |
| 1049 | // to all client applications using this effect and notifies applications of effect state, |
| 1050 | // control or parameter changes. It manages the activation state machine to send appropriate |
| 1051 | // reset, enable, disable commands to effect engine and provide volume |
| 1052 | // ramping when effects are activated/deactivated. |
| 1053 | // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by |
| 1054 | // the attached track(s) to accumulate their auxiliary channel. |
| 1055 | class EffectModule: public RefBase { |
| 1056 | public: |
| 1057 | EffectModule(const wp<ThreadBase>& wThread, |
| 1058 | const wp<AudioFlinger::EffectChain>& chain, |
| 1059 | effect_descriptor_t *desc, |
| 1060 | int id, |
| 1061 | int sessionId); |
| 1062 | ~EffectModule(); |
| 1063 | |
| 1064 | enum effect_state { |
| 1065 | IDLE, |
| 1066 | RESTART, |
| 1067 | STARTING, |
| 1068 | ACTIVE, |
| 1069 | STOPPING, |
Eric Laurent | ec437d8 | 2011-07-26 20:54:46 -0700 | [diff] [blame] | 1070 | STOPPED, |
| 1071 | DESTROYED |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1072 | }; |
| 1073 | |
| 1074 | int id() { return mId; } |
| 1075 | void process(); |
| 1076 | void updateState(); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1077 | status_t command(uint32_t cmdCode, |
| 1078 | uint32_t cmdSize, |
| 1079 | void *pCmdData, |
| 1080 | uint32_t *replySize, |
| 1081 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1082 | |
| 1083 | void reset_l(); |
| 1084 | status_t configure(); |
| 1085 | status_t init(); |
| 1086 | uint32_t state() { |
| 1087 | return mState; |
| 1088 | } |
| 1089 | uint32_t status() { |
| 1090 | return mStatus; |
| 1091 | } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1092 | int sessionId() { |
| 1093 | return mSessionId; |
| 1094 | } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1095 | status_t setEnabled(bool enabled); |
| 1096 | bool isEnabled(); |
Eric Laurent | 8f45bd7 | 2010-08-31 13:50:07 -0700 | [diff] [blame] | 1097 | bool isProcessEnabled(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1098 | |
| 1099 | void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; } |
| 1100 | int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; } |
| 1101 | void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; } |
| 1102 | int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1103 | void setChain(const wp<EffectChain>& chain) { mChain = chain; } |
| 1104 | void setThread(const wp<ThreadBase>& thread) { mThread = thread; } |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1105 | wp<ThreadBase>& thread() { return mThread; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1106 | |
| 1107 | status_t addHandle(sp<EffectHandle>& handle); |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1108 | void disconnect(const wp<EffectHandle>& handle, bool unpiniflast); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1109 | size_t removeHandle (const wp<EffectHandle>& handle); |
| 1110 | |
| 1111 | effect_descriptor_t& desc() { return mDescriptor; } |
| 1112 | wp<EffectChain>& chain() { return mChain; } |
| 1113 | |
| 1114 | status_t setDevice(uint32_t device); |
| 1115 | status_t setVolume(uint32_t *left, uint32_t *right, bool controller); |
| 1116 | status_t setMode(uint32_t mode); |
Eric Laurent | ec35a14 | 2011-10-05 17:42:25 -0700 | [diff] [blame] | 1117 | status_t start(); |
Eric Laurent | ec437d8 | 2011-07-26 20:54:46 -0700 | [diff] [blame] | 1118 | status_t stop(); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1119 | void setSuspended(bool suspended); |
Glenn Kasten | a3a8548 | 2012-01-04 11:01:11 -0800 | [diff] [blame] | 1120 | bool suspended() const; |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1121 | |
| 1122 | sp<EffectHandle> controlHandle(); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1123 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1124 | bool isPinned() { return mPinned; } |
| 1125 | void unPin() { mPinned = false; } |
| 1126 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1127 | status_t dump(int fd, const Vector<String16>& args); |
| 1128 | |
| 1129 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1130 | friend class EffectHandle; |
| 1131 | friend class AudioFlinger; |
| 1132 | bool mPinned; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1133 | |
| 1134 | // Maximum time allocated to effect engines to complete the turn off sequence |
| 1135 | static const uint32_t MAX_DISABLE_TIME_MS = 10000; |
| 1136 | |
| 1137 | EffectModule(const EffectModule&); |
| 1138 | EffectModule& operator = (const EffectModule&); |
| 1139 | |
| 1140 | status_t start_l(); |
| 1141 | status_t stop_l(); |
| 1142 | |
Glenn Kasten | a3a8548 | 2012-01-04 11:01:11 -0800 | [diff] [blame] | 1143 | mutable Mutex mLock; // mutex for process, commands and handles list protection |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1144 | wp<ThreadBase> mThread; // parent thread |
| 1145 | wp<EffectChain> mChain; // parent effect chain |
| 1146 | int mId; // this instance unique ID |
| 1147 | int mSessionId; // audio session ID |
| 1148 | effect_descriptor_t mDescriptor;// effect descriptor received from effect engine |
| 1149 | effect_config_t mConfig; // input and output audio configuration |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 1150 | effect_handle_t mEffectInterface; // Effect module C API |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1151 | status_t mStatus; // initialization status |
| 1152 | uint32_t mState; // current activation state (effect_state) |
| 1153 | Vector< wp<EffectHandle> > mHandles; // list of client handles |
| 1154 | uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after |
| 1155 | // sending disable command. |
| 1156 | uint32_t mDisableWaitCnt; // current process() calls count during disable period. |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1157 | bool mSuspended; // effect is suspended: temporarily disabled by framework |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1158 | }; |
| 1159 | |
| 1160 | // The EffectHandle class implements the IEffect interface. It provides resources |
| 1161 | // to receive parameter updates, keeps track of effect control |
| 1162 | // ownership and state and has a pointer to the EffectModule object it is controlling. |
| 1163 | // There is one EffectHandle object for each application controlling (or using) |
| 1164 | // an effect module. |
| 1165 | // The EffectHandle is obtained by calling AudioFlinger::createEffect(). |
| 1166 | class EffectHandle: public android::BnEffect { |
| 1167 | public: |
| 1168 | |
| 1169 | EffectHandle(const sp<EffectModule>& effect, |
| 1170 | const sp<AudioFlinger::Client>& client, |
| 1171 | const sp<IEffectClient>& effectClient, |
| 1172 | int32_t priority); |
| 1173 | virtual ~EffectHandle(); |
| 1174 | |
| 1175 | // IEffect |
| 1176 | virtual status_t enable(); |
| 1177 | virtual status_t disable(); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1178 | virtual status_t command(uint32_t cmdCode, |
| 1179 | uint32_t cmdSize, |
| 1180 | void *pCmdData, |
| 1181 | uint32_t *replySize, |
| 1182 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1183 | virtual void disconnect(); |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1184 | virtual void disconnect(bool unpiniflast); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1185 | virtual sp<IMemory> getCblk() const; |
| 1186 | virtual status_t onTransact(uint32_t code, const Parcel& data, |
| 1187 | Parcel* reply, uint32_t flags); |
| 1188 | |
| 1189 | |
| 1190 | // Give or take control of effect module |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1191 | // - hasControl: true if control is given, false if removed |
| 1192 | // - signal: true client app should be signaled of change, false otherwise |
| 1193 | // - enabled: state of the effect when control is passed |
| 1194 | void setControl(bool hasControl, bool signal, bool enabled); |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 1195 | void commandExecuted(uint32_t cmdCode, |
| 1196 | uint32_t cmdSize, |
| 1197 | void *pCmdData, |
| 1198 | uint32_t replySize, |
| 1199 | void *pReplyData); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1200 | void setEnabled(bool enabled); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1201 | bool enabled() { return mEnabled; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1202 | |
| 1203 | // Getters |
| 1204 | int id() { return mEffect->id(); } |
| 1205 | int priority() { return mPriority; } |
| 1206 | bool hasControl() { return mHasControl; } |
| 1207 | sp<EffectModule> effect() { return mEffect; } |
| 1208 | |
| 1209 | void dump(char* buffer, size_t size); |
| 1210 | |
| 1211 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1212 | friend class AudioFlinger; |
| 1213 | friend class EffectModule; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1214 | EffectHandle(const EffectHandle&); |
| 1215 | EffectHandle& operator =(const EffectHandle&); |
| 1216 | |
| 1217 | sp<EffectModule> mEffect; // pointer to controlled EffectModule |
| 1218 | sp<IEffectClient> mEffectClient; // callback interface for client notifications |
| 1219 | sp<Client> mClient; // client for shared memory allocation |
| 1220 | sp<IMemory> mCblkMemory; // shared memory for control block |
| 1221 | effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory |
| 1222 | uint8_t* mBuffer; // pointer to parameter area in shared memory |
| 1223 | int mPriority; // client application priority to control the effect |
| 1224 | bool mHasControl; // true if this handle is controlling the effect |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1225 | bool mEnabled; // cached enable state: needed when the effect is |
| 1226 | // restored after being suspended |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1227 | }; |
| 1228 | |
| 1229 | // the EffectChain class represents a group of effects associated to one audio session. |
| 1230 | // There can be any number of EffectChain objects per output mixer thread (PlaybackThread). |
| 1231 | // The EffecChain with session ID 0 contains global effects applied to the output mix. |
| 1232 | // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks) |
| 1233 | // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding |
| 1234 | // in the effect process order. When attached to a track (session ID != 0), it also provide it's own |
| 1235 | // input buffer used by the track as accumulation buffer. |
| 1236 | class EffectChain: public RefBase { |
| 1237 | public: |
| 1238 | EffectChain(const wp<ThreadBase>& wThread, int sessionId); |
| 1239 | ~EffectChain(); |
| 1240 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1241 | // special key used for an entry in mSuspendedEffects keyed vector |
| 1242 | // corresponding to a suspend all request. |
| 1243 | static const int kKeyForSuspendAll = 0; |
| 1244 | |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1245 | // minimum duration during which we force calling effect process when last track on |
| 1246 | // a session is stopped or removed to allow effect tail to be rendered |
| 1247 | static const int kProcessTailDurationMs = 1000; |
| 1248 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1249 | void process_l(); |
| 1250 | |
| 1251 | void lock() { |
| 1252 | mLock.lock(); |
| 1253 | } |
| 1254 | void unlock() { |
| 1255 | mLock.unlock(); |
| 1256 | } |
| 1257 | |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1258 | status_t addEffect_l(const sp<EffectModule>& handle); |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1259 | size_t removeEffect_l(const sp<EffectModule>& handle); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1260 | |
Eric Laurent | 7c7f10b | 2011-06-17 21:29:58 -0700 | [diff] [blame] | 1261 | int sessionId() { return mSessionId; } |
| 1262 | void setSessionId(int sessionId) { mSessionId = sessionId; } |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1263 | |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1264 | sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor); |
| 1265 | sp<EffectModule> getEffectFromId_l(int id); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1266 | sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type); |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1267 | bool setVolume_l(uint32_t *left, uint32_t *right); |
| 1268 | void setDevice_l(uint32_t device); |
| 1269 | void setMode_l(uint32_t mode); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1270 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1271 | void setInBuffer(int16_t *buffer, bool ownsBuffer = false) { |
| 1272 | mInBuffer = buffer; |
| 1273 | mOwnInBuffer = ownsBuffer; |
| 1274 | } |
| 1275 | int16_t *inBuffer() { |
| 1276 | return mInBuffer; |
| 1277 | } |
| 1278 | void setOutBuffer(int16_t *buffer) { |
| 1279 | mOutBuffer = buffer; |
| 1280 | } |
| 1281 | int16_t *outBuffer() { |
| 1282 | return mOutBuffer; |
| 1283 | } |
| 1284 | |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1285 | void incTrackCnt() { android_atomic_inc(&mTrackCnt); } |
| 1286 | void decTrackCnt() { android_atomic_dec(&mTrackCnt); } |
| 1287 | int32_t trackCnt() { return mTrackCnt;} |
| 1288 | |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1289 | void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt); |
| 1290 | mTailBufferCount = mMaxTailBuffers; } |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1291 | void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); } |
| 1292 | int32_t activeTrackCnt() { return mActiveTrackCnt;} |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1293 | |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1294 | uint32_t strategy() { return mStrategy; } |
| 1295 | void setStrategy(uint32_t strategy) |
| 1296 | { mStrategy = strategy; } |
| 1297 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1298 | // suspend effect of the given type |
| 1299 | void setEffectSuspended_l(const effect_uuid_t *type, |
| 1300 | bool suspend); |
| 1301 | // suspend all eligible effects |
| 1302 | void setEffectSuspendedAll_l(bool suspend); |
| 1303 | // 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] | 1304 | void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1305 | bool enabled); |
| 1306 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1307 | status_t dump(int fd, const Vector<String16>& args); |
| 1308 | |
| 1309 | protected: |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1310 | friend class AudioFlinger; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1311 | EffectChain(const EffectChain&); |
| 1312 | EffectChain& operator =(const EffectChain&); |
| 1313 | |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1314 | class SuspendedEffectDesc : public RefBase { |
| 1315 | public: |
| 1316 | SuspendedEffectDesc() : mRefCount(0) {} |
| 1317 | |
| 1318 | int mRefCount; |
| 1319 | effect_uuid_t mType; |
| 1320 | wp<EffectModule> mEffect; |
| 1321 | }; |
| 1322 | |
| 1323 | // get a list of effect modules to suspend when an effect of the type |
| 1324 | // passed is enabled. |
| 1325 | Vector< sp<EffectModule> > getSuspendEligibleEffects(); |
| 1326 | // get an effect module if it is currently enable |
| 1327 | sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type); |
Eric Laurent | db7c079 | 2011-08-10 10:37:50 -0700 | [diff] [blame] | 1328 | // true if the effect whose descriptor is passed can be suspended |
| 1329 | // OEMs can modify the rules implemented in this method to exclude specific effect |
| 1330 | // types or implementations from the suspend/restore mechanism. |
| 1331 | bool isEffectEligibleForSuspend(const effect_descriptor_t& desc); |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1332 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1333 | wp<ThreadBase> mThread; // parent mixer thread |
| 1334 | Mutex mLock; // mutex protecting effect list |
| 1335 | Vector<sp<EffectModule> > mEffects; // list of effect modules |
| 1336 | int mSessionId; // audio session ID |
| 1337 | int16_t *mInBuffer; // chain input buffer |
| 1338 | int16_t *mOutBuffer; // chain output buffer |
Eric Laurent | b469b94 | 2011-05-09 12:09:06 -0700 | [diff] [blame] | 1339 | volatile int32_t mActiveTrackCnt; // number of active tracks connected |
| 1340 | volatile int32_t mTrackCnt; // number of tracks connected |
Eric Laurent | 544fe9b | 2011-11-11 15:42:52 -0800 | [diff] [blame] | 1341 | int32_t mTailBufferCount; // current effect tail buffer count |
| 1342 | int32_t mMaxTailBuffers; // maximum effect tail buffers |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1343 | bool mOwnInBuffer; // true if the chain owns its input buffer |
Eric Laurent | cab1124 | 2010-07-15 12:50:15 -0700 | [diff] [blame] | 1344 | int mVolumeCtrlIdx; // index of insert effect having control over volume |
| 1345 | uint32_t mLeftVolume; // previous volume on left channel |
| 1346 | uint32_t mRightVolume; // previous volume on right channel |
Eric Laurent | f997cab | 2010-07-19 06:24:46 -0700 | [diff] [blame] | 1347 | uint32_t mNewLeftVolume; // new volume on left channel |
| 1348 | uint32_t mNewRightVolume; // new volume on right channel |
Eric Laurent | de07013 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 1349 | uint32_t mStrategy; // strategy for this effect chain |
Eric Laurent | 59255e4 | 2011-07-27 19:49:51 -0700 | [diff] [blame] | 1350 | // mSuspendedEffects lists all effect currently suspended in the chain |
| 1351 | // use effect type UUID timelow field as key. There is no real risk of identical |
| 1352 | // timeLow fields among effect type UUIDs. |
| 1353 | KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1354 | }; |
| 1355 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1356 | struct AudioStreamOut { |
| 1357 | audio_hw_device_t *hwDev; |
| 1358 | audio_stream_out_t *stream; |
| 1359 | |
| 1360 | AudioStreamOut(audio_hw_device_t *dev, audio_stream_out_t *out) : |
| 1361 | hwDev(dev), stream(out) {} |
| 1362 | }; |
| 1363 | |
| 1364 | struct AudioStreamIn { |
| 1365 | audio_hw_device_t *hwDev; |
| 1366 | audio_stream_in_t *stream; |
| 1367 | |
| 1368 | AudioStreamIn(audio_hw_device_t *dev, audio_stream_in_t *in) : |
| 1369 | hwDev(dev), stream(in) {} |
| 1370 | }; |
| 1371 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1372 | struct AudioSessionRef { |
| 1373 | int sessionid; |
| 1374 | pid_t pid; |
| 1375 | int cnt; |
| 1376 | }; |
| 1377 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1378 | friend class RecordThread; |
| 1379 | friend class PlaybackThread; |
| 1380 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1381 | mutable Mutex mLock; |
| 1382 | |
| 1383 | DefaultKeyedVector< pid_t, wp<Client> > mClients; |
| 1384 | |
| 1385 | mutable Mutex mHardwareLock; |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1386 | audio_hw_device_t* mPrimaryHardwareDev; |
| 1387 | Vector<audio_hw_device_t*> mAudioHwDevs; |
Glenn Kasten | a4454b4 | 2012-01-04 11:02:33 -0800 | [diff] [blame] | 1388 | mutable hardware_call_state mHardwareStatus; // for dump only |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1389 | |
| 1390 | |
| 1391 | DefaultKeyedVector< int, sp<PlaybackThread> > mPlaybackThreads; |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 1392 | PlaybackThread::stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame^] | 1393 | |
| 1394 | // both are protected by mLock |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1395 | float mMasterVolume; |
| 1396 | bool mMasterMute; |
| 1397 | |
| 1398 | DefaultKeyedVector< int, sp<RecordThread> > mRecordThreads; |
| 1399 | |
| 1400 | DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients; |
| 1401 | volatile int32_t mNextUniqueId; |
Eric Laurent | 59bd0da | 2011-08-01 09:52:20 -0700 | [diff] [blame] | 1402 | uint32_t mMode; |
Eric Laurent | bee5337 | 2011-08-29 12:42:48 -0700 | [diff] [blame] | 1403 | bool mBtNrecIsOff; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1404 | |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 1405 | Vector<AudioSessionRef*> mAudioSessionRefs; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame^] | 1406 | |
| 1407 | float masterVolume_l() const { return mMasterVolume; } |
| 1408 | bool masterMute_l() const { return mMasterMute; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1409 | }; |
| 1410 | |
Dima Zavin | 799a70e | 2011-04-18 16:57:27 -0700 | [diff] [blame] | 1411 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 1412 | // ---------------------------------------------------------------------------- |
| 1413 | |
| 1414 | }; // namespace android |
| 1415 | |
| 1416 | #endif // ANDROID_AUDIO_FLINGER_H |