blob: 2e055934bd75cb37a437755d4f686025b7606f2f [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/* //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>
Eric Laurent8ac9f8d2009-12-18 05:47:48 -080023#include <limits.h>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080024
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>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080034#include <utils/SortedVector.h>
Dima Zavin31f188892011-04-18 16:57:27 -070035#include <utils/TypeHelpers.h>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080036#include <utils/Vector.h>
37
Mathias Agopian24651682010-07-14 18:41:18 -070038#include <binder/BinderService.h>
39#include <binder/MemoryDealer.h>
40
Dima Zavin34bb4192011-05-11 14:15:23 -070041#include <system/audio.h>
Dima Zavin290029d2011-06-13 18:16:26 -070042#include <hardware/audio.h>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080043
44#include "AudioBufferProvider.h"
45
Eric Laurent6dbdc402011-07-22 09:04:31 -070046#include <powermanager/IPowerManager.h>
47
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080048namespace android {
49
50class audio_track_cblk_t;
Eric Laurent65b65452010-06-01 23:49:17 -070051class effect_param_cblk_t;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080052class AudioMixer;
53class AudioBuffer;
Eric Laurenta553c252009-07-17 12:17:14 -070054class AudioResampler;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080055
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080056// ----------------------------------------------------------------------------
57
58#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
59#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
60
61
62// ----------------------------------------------------------------------------
63
64static const nsecs_t kStandbyTimeInNsecs = seconds(3);
65
Mathias Agopian24651682010-07-14 18:41:18 -070066class AudioFlinger :
67 public BinderService<AudioFlinger>,
68 public BnAudioFlinger
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080069{
Mathias Agopian24651682010-07-14 18:41:18 -070070 friend class BinderService<AudioFlinger>;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080071public:
Mathias Agopian24651682010-07-14 18:41:18 -070072 static char const* getServiceName() { return "media.audio_flinger"; }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080073
74 virtual status_t dump(int fd, const Vector<String16>& args);
75
76 // IAudioFlinger interface
77 virtual sp<IAudioTrack> createTrack(
78 pid_t pid,
79 int streamType,
80 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -070081 uint32_t format,
82 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080083 int frameCount,
84 uint32_t flags,
85 const sp<IMemory>& sharedBuffer,
Eric Laurentddb78e72009-07-28 08:44:33 -070086 int output,
Eric Laurent65b65452010-06-01 23:49:17 -070087 int *sessionId,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080088 status_t *status);
89
Eric Laurentddb78e72009-07-28 08:44:33 -070090 virtual uint32_t sampleRate(int output) const;
91 virtual int channelCount(int output) const;
Jean-Michel Trivi54392232011-05-24 15:53:33 -070092 virtual uint32_t format(int output) const;
Eric Laurentddb78e72009-07-28 08:44:33 -070093 virtual size_t frameCount(int output) const;
94 virtual uint32_t latency(int output) const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080095
96 virtual status_t setMasterVolume(float value);
97 virtual status_t setMasterMute(bool muted);
98
99 virtual float masterVolume() const;
100 virtual bool masterMute() const;
101
Eric Laurentddb78e72009-07-28 08:44:33 -0700102 virtual status_t setStreamVolume(int stream, float value, int output);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800103 virtual status_t setStreamMute(int stream, bool muted);
104
Eric Laurentddb78e72009-07-28 08:44:33 -0700105 virtual float streamVolume(int stream, int output) const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800106 virtual bool streamMute(int stream) const;
107
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800108 virtual status_t setMode(int mode);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800109
110 virtual status_t setMicMute(bool state);
111 virtual bool getMicMute() const;
112
Eric Laurentddb78e72009-07-28 08:44:33 -0700113 virtual status_t setParameters(int ioHandle, const String8& keyValuePairs);
114 virtual String8 getParameters(int ioHandle, const String8& keys);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800115
116 virtual void registerClient(const sp<IAudioFlingerClient>& client);
Eric Laurenta553c252009-07-17 12:17:14 -0700117
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800118 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
Eric Laurent47d0a922010-02-26 02:47:27 -0800119 virtual unsigned int getInputFramesLost(int ioHandle);
Eric Laurenta553c252009-07-17 12:17:14 -0700120
Eric Laurentddb78e72009-07-28 08:44:33 -0700121 virtual int openOutput(uint32_t *pDevices,
Eric Laurenta553c252009-07-17 12:17:14 -0700122 uint32_t *pSamplingRate,
123 uint32_t *pFormat,
124 uint32_t *pChannels,
125 uint32_t *pLatencyMs,
126 uint32_t flags);
127
Eric Laurentddb78e72009-07-28 08:44:33 -0700128 virtual int openDuplicateOutput(int output1, int output2);
Eric Laurenta553c252009-07-17 12:17:14 -0700129
Eric Laurentddb78e72009-07-28 08:44:33 -0700130 virtual status_t closeOutput(int output);
Eric Laurenta553c252009-07-17 12:17:14 -0700131
Eric Laurentddb78e72009-07-28 08:44:33 -0700132 virtual status_t suspendOutput(int output);
Eric Laurenta553c252009-07-17 12:17:14 -0700133
Eric Laurentddb78e72009-07-28 08:44:33 -0700134 virtual status_t restoreOutput(int output);
Eric Laurenta553c252009-07-17 12:17:14 -0700135
Eric Laurentddb78e72009-07-28 08:44:33 -0700136 virtual int openInput(uint32_t *pDevices,
Eric Laurenta553c252009-07-17 12:17:14 -0700137 uint32_t *pSamplingRate,
138 uint32_t *pFormat,
139 uint32_t *pChannels,
140 uint32_t acoustics);
141
Eric Laurentddb78e72009-07-28 08:44:33 -0700142 virtual status_t closeInput(int input);
Eric Laurenta553c252009-07-17 12:17:14 -0700143
Eric Laurentddb78e72009-07-28 08:44:33 -0700144 virtual status_t setStreamOutput(uint32_t stream, int output);
Eric Laurenta553c252009-07-17 12:17:14 -0700145
Eric Laurent415f3e22009-10-21 08:14:22 -0700146 virtual status_t setVoiceVolume(float volume);
147
Eric Laurent0986e792010-01-19 17:37:09 -0800148 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output);
149
Eric Laurent65b65452010-06-01 23:49:17 -0700150 virtual int newAudioSessionId();
151
Marco Nelissenc74b93f2011-08-02 13:33:41 -0700152 virtual void acquireAudioSessionId(int audioSession);
153
154 virtual void releaseAudioSessionId(int audioSession);
155
Eric Laurent65b65452010-06-01 23:49:17 -0700156 virtual status_t queryNumberEffects(uint32_t *numEffects);
157
Eric Laurent53334cd2010-06-23 17:38:20 -0700158 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor);
Eric Laurent65b65452010-06-01 23:49:17 -0700159
160 virtual status_t getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor);
161
162 virtual sp<IEffect> createEffect(pid_t pid,
163 effect_descriptor_t *pDesc,
164 const sp<IEffectClient>& effectClient,
165 int32_t priority,
Eric Laurent464d5b32011-06-17 21:29:58 -0700166 int io,
Eric Laurent65b65452010-06-01 23:49:17 -0700167 int sessionId,
168 status_t *status,
169 int *id,
170 int *enabled);
171
Eric Laurentf82fccd2011-07-27 19:49:51 -0700172 virtual status_t moveEffects(int sessionId, int srcOutput, int dstOutput);
Eric Laurent53334cd2010-06-23 17:38:20 -0700173
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800174 enum hardware_call_state {
175 AUDIO_HW_IDLE = 0,
176 AUDIO_HW_INIT,
177 AUDIO_HW_OUTPUT_OPEN,
178 AUDIO_HW_OUTPUT_CLOSE,
179 AUDIO_HW_INPUT_OPEN,
180 AUDIO_HW_INPUT_CLOSE,
181 AUDIO_HW_STANDBY,
182 AUDIO_HW_SET_MASTER_VOLUME,
183 AUDIO_HW_GET_ROUTING,
184 AUDIO_HW_SET_ROUTING,
185 AUDIO_HW_GET_MODE,
186 AUDIO_HW_SET_MODE,
187 AUDIO_HW_GET_MIC_MUTE,
188 AUDIO_HW_SET_MIC_MUTE,
189 AUDIO_SET_VOICE_VOLUME,
190 AUDIO_SET_PARAMETER,
191 };
192
193 // record interface
194 virtual sp<IAudioRecord> openRecord(
195 pid_t pid,
Eric Laurentddb78e72009-07-28 08:44:33 -0700196 int input,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800197 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700198 uint32_t format,
199 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800200 int frameCount,
201 uint32_t flags,
Eric Laurent65b65452010-06-01 23:49:17 -0700202 int *sessionId,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800203 status_t *status);
204
205 virtual status_t onTransact(
206 uint32_t code,
207 const Parcel& data,
208 Parcel* reply,
209 uint32_t flags);
210
Eric Laurent53334cd2010-06-23 17:38:20 -0700211 uint32_t getMode() { return mMode; }
212
Eric Laurent2d95dfb2011-08-29 12:42:48 -0700213 bool btNrecIsOff() { return mBtNrecIsOff; }
Eric Laurent6639b552011-08-01 09:52:20 -0700214
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800215private:
216 AudioFlinger();
217 virtual ~AudioFlinger();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800218
Dima Zavin2986f5b2011-04-19 19:04:32 -0700219 status_t initCheck() const;
220 virtual void onFirstRef();
Dima Zavin31f188892011-04-18 16:57:27 -0700221 audio_hw_device_t* findSuitableHwDev_l(uint32_t devices);
Marco Nelissenc74b93f2011-08-02 13:33:41 -0700222 void purgeStaleEffects_l();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800223
224 // Internal dump utilites.
225 status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
226 status_t dumpClients(int fd, const Vector<String16>& args);
227 status_t dumpInternals(int fd, const Vector<String16>& args);
228
229 // --- Client ---
230 class Client : public RefBase {
231 public:
232 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
233 virtual ~Client();
234 const sp<MemoryDealer>& heap() const;
235 pid_t pid() const { return mPid; }
Eric Laurentb9481d82009-09-17 05:12:56 -0700236 sp<AudioFlinger> audioFlinger() { return mAudioFlinger; }
237
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800238 private:
239 Client(const Client&);
240 Client& operator = (const Client&);
241 sp<AudioFlinger> mAudioFlinger;
242 sp<MemoryDealer> mMemoryDealer;
243 pid_t mPid;
244 };
245
Eric Laurent4f0f17d2010-05-12 02:05:53 -0700246 // --- 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
254 sp<IAudioFlingerClient> client() { return mClient; }
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
263 sp<AudioFlinger> mAudioFlinger;
264 pid_t mPid;
265 sp<IAudioFlingerClient> mClient;
266 };
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800267
268 class TrackHandle;
269 class RecordHandle;
Eric Laurenta553c252009-07-17 12:17:14 -0700270 class RecordThread;
271 class PlaybackThread;
272 class MixerThread;
273 class DirectOutputThread;
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800274 class DuplicatingThread;
Eric Laurenta553c252009-07-17 12:17:14 -0700275 class Track;
276 class RecordTrack;
Eric Laurent65b65452010-06-01 23:49:17 -0700277 class EffectModule;
278 class EffectHandle;
279 class EffectChain;
Dima Zavin31f188892011-04-18 16:57:27 -0700280 struct AudioStreamOut;
281 struct AudioStreamIn;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800282
Eric Laurenta553c252009-07-17 12:17:14 -0700283 class ThreadBase : public Thread {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800284 public:
Eric Laurent464d5b32011-06-17 21:29:58 -0700285 ThreadBase (const sp<AudioFlinger>& audioFlinger, int id, uint32_t device);
Eric Laurenta553c252009-07-17 12:17:14 -0700286 virtual ~ThreadBase();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800287
Eric Laurent464d5b32011-06-17 21:29:58 -0700288
289 enum type {
290 MIXER, // Thread class is MixerThread
291 DIRECT, // Thread class is DirectOutputThread
292 DUPLICATING, // Thread class is DuplicatingThread
293 RECORD // Thread class is RecordThread
294 };
295
Eric Laurent3fdb1262009-11-07 00:01:32 -0800296 status_t dumpBase(int fd, const Vector<String16>& args);
Eric Laurent1345d332011-07-24 17:49:51 -0700297 status_t dumpEffectChains(int fd, const Vector<String16>& args);
Eric Laurent3fdb1262009-11-07 00:01:32 -0800298
Eric Laurent6dbdc402011-07-22 09:04:31 -0700299 void clearPowerManager();
300
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800301 // base for record and playback
302 class TrackBase : public AudioBufferProvider, public RefBase {
303
304 public:
305 enum track_state {
306 IDLE,
307 TERMINATED,
308 STOPPED,
309 RESUMING,
310 ACTIVE,
311 PAUSING,
312 PAUSED
313 };
314
315 enum track_flags {
316 STEPSERVER_FAILED = 0x01, // StepServer could not acquire cblk->lock mutex
317 SYSTEM_FLAGS_MASK = 0x0000ffffUL,
318 // The upper 16 bits are used for track-specific flags.
319 };
320
Eric Laurenta553c252009-07-17 12:17:14 -0700321 TrackBase(const wp<ThreadBase>& thread,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800322 const sp<Client>& client,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800323 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700324 uint32_t format,
325 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800326 int frameCount,
327 uint32_t flags,
Eric Laurent65b65452010-06-01 23:49:17 -0700328 const sp<IMemory>& sharedBuffer,
329 int sessionId);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800330 ~TrackBase();
331
332 virtual status_t start() = 0;
333 virtual void stop() = 0;
334 sp<IMemory> getCblk() const;
Eric Laurent6c30a712009-08-10 23:22:32 -0700335 audio_track_cblk_t* cblk() const { return mCblk; }
Eric Laurent65b65452010-06-01 23:49:17 -0700336 int sessionId() { return mSessionId; }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800337
338 protected:
Eric Laurenta553c252009-07-17 12:17:14 -0700339 friend class ThreadBase;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800340 friend class RecordHandle;
Eric Laurent2c817f52009-07-23 13:17:39 -0700341 friend class PlaybackThread;
342 friend class RecordThread;
343 friend class MixerThread;
344 friend class DirectOutputThread;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800345
346 TrackBase(const TrackBase&);
347 TrackBase& operator = (const TrackBase&);
348
349 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
350 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
351
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700352 uint32_t format() const {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800353 return mFormat;
354 }
355
356 int channelCount() const ;
357
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700358 uint32_t channelMask() const;
359
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800360 int sampleRate() const;
361
362 void* getBuffer(uint32_t offset, uint32_t frames) const;
363
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800364 bool isStopped() const {
365 return mState == STOPPED;
366 }
367
368 bool isTerminated() const {
369 return mState == TERMINATED;
370 }
371
372 bool step();
373 void reset();
374
Eric Laurenta553c252009-07-17 12:17:14 -0700375 wp<ThreadBase> mThread;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800376 sp<Client> mClient;
377 sp<IMemory> mCblkMemory;
378 audio_track_cblk_t* mCblk;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800379 void* mBuffer;
380 void* mBufferEnd;
381 uint32_t mFrameCount;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800382 // we don't really need a lock for these
383 int mState;
384 int mClientTid;
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700385 uint32_t mFormat;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800386 uint32_t mFlags;
Eric Laurent65b65452010-06-01 23:49:17 -0700387 int mSessionId;
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700388 uint8_t mChannelCount;
389 uint32_t mChannelMask;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800390 };
391
Eric Laurenta553c252009-07-17 12:17:14 -0700392 class ConfigEvent {
393 public:
394 ConfigEvent() : mEvent(0), mParam(0) {}
395
396 int mEvent;
397 int mParam;
398 };
399
Eric Laurent6dbdc402011-07-22 09:04:31 -0700400 class PMDeathRecipient : public IBinder::DeathRecipient {
401 public:
402 PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
403 virtual ~PMDeathRecipient() {}
404
405 // IBinder::DeathRecipient
406 virtual void binderDied(const wp<IBinder>& who);
407
408 private:
409 PMDeathRecipient(const PMDeathRecipient&);
410 PMDeathRecipient& operator = (const PMDeathRecipient&);
411
412 wp<ThreadBase> mThread;
413 };
414
Eric Laurent464d5b32011-06-17 21:29:58 -0700415 virtual status_t initCheck() const = 0;
416 int type() const { return mType; }
Eric Laurenta553c252009-07-17 12:17:14 -0700417 uint32_t sampleRate() const;
418 int channelCount() const;
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700419 uint32_t format() const;
Eric Laurenta553c252009-07-17 12:17:14 -0700420 size_t frameCount() const;
421 void wakeUp() { mWaitWorkCV.broadcast(); }
422 void exit();
423 virtual bool checkForNewParameters_l() = 0;
424 virtual status_t setParameters(const String8& keyValuePairs);
425 virtual String8 getParameters(const String8& keys) = 0;
Eric Laurenteb8f850d2010-05-14 03:26:45 -0700426 virtual void audioConfigChanged_l(int event, int param = 0) = 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700427 void sendConfigEvent(int event, int param = 0);
Eric Laurent8fce46a2009-08-04 09:45:33 -0700428 void sendConfigEvent_l(int event, int param = 0);
Eric Laurenta553c252009-07-17 12:17:14 -0700429 void processConfigEvents();
Eric Laurent49f02be2009-11-19 09:00:56 -0800430 int id() const { return mId;}
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800431 bool standby() { return mStandby; }
Eric Laurent464d5b32011-06-17 21:29:58 -0700432 uint32_t device() { return mDevice; }
433 virtual audio_stream_t* stream() = 0;
434
435 sp<EffectHandle> createEffect_l(
436 const sp<AudioFlinger::Client>& client,
437 const sp<IEffectClient>& effectClient,
438 int32_t priority,
439 int sessionId,
440 effect_descriptor_t *desc,
441 int *enabled,
442 status_t *status);
443 void disconnectEffect(const sp< EffectModule>& effect,
Marco Nelissenc74b93f2011-08-02 13:33:41 -0700444 const wp<EffectHandle>& handle,
445 bool unpiniflast);
Eric Laurent464d5b32011-06-17 21:29:58 -0700446
447 // return values for hasAudioSession (bit field)
448 enum effect_state {
449 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
450 // effect
451 TRACK_SESSION = 0x2 // the audio session corresponds to at least one
452 // track
453 };
454
455 // get effect chain corresponding to session Id.
456 sp<EffectChain> getEffectChain(int sessionId);
457 // same as getEffectChain() but must be called with ThreadBase mutex locked
458 sp<EffectChain> getEffectChain_l(int sessionId);
459 // add an effect chain to the chain list (mEffectChains)
460 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
461 // remove an effect chain from the chain list (mEffectChains)
462 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
463 // lock mall effect chains Mutexes. Must be called before releasing the
464 // ThreadBase mutex before processing the mixer and effects. This guarantees the
465 // integrity of the chains during the process.
466 void lockEffectChains_l(Vector<sp <EffectChain> >& effectChains);
467 // unlock effect chains after process
468 void unlockEffectChains(Vector<sp <EffectChain> >& effectChains);
469 // set audio mode to all effect chains
470 void setMode(uint32_t mode);
471 // get effect module with corresponding ID on specified audio session
472 sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId);
473 // add and effect module. Also creates the effect chain is none exists for
474 // the effects audio session
475 status_t addEffect_l(const sp< EffectModule>& effect);
476 // remove and effect module. Also removes the effect chain is this was the last
477 // effect
478 void removeEffect_l(const sp< EffectModule>& effect);
479 // detach all tracks connected to an auxiliary effect
480 virtual void detachAuxEffect_l(int effectId) {}
481 // returns either EFFECT_SESSION if effects on this audio session exist in one
482 // chain, or TRACK_SESSION if tracks on this audio session exist, or both
483 virtual uint32_t hasAudioSession(int sessionId) = 0;
484 // the value returned by default implementation is not important as the
485 // strategy is only meaningful for PlaybackThread which implements this method
486 virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; }
Eric Laurenta553c252009-07-17 12:17:14 -0700487
Eric Laurentf82fccd2011-07-27 19:49:51 -0700488 // suspend or restore effect according to the type of effect passed. a NULL
489 // type pointer means suspend all effects in the session
490 void setEffectSuspended(const effect_uuid_t *type,
491 bool suspend,
492 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
493 // check if some effects must be suspended/restored when an effect is enabled
494 // or disabled
495 virtual void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
496 bool enabled,
497 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
498
Eric Laurent2c817f52009-07-23 13:17:39 -0700499 mutable Mutex mLock;
500
Eric Laurenta553c252009-07-17 12:17:14 -0700501 protected:
502
Eric Laurentf82fccd2011-07-27 19:49:51 -0700503 // 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 Laurent6dbdc402011-07-22 09:04:31 -0700512 void acquireWakeLock();
513 void acquireWakeLock_l();
514 void releaseWakeLock();
515 void releaseWakeLock_l();
Eric Laurentf82fccd2011-07-27 19:49:51 -0700516 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 Laurent6dbdc402011-07-22 09:04:31 -0700525
Marco Nelissenc74b93f2011-08-02 13:33:41 -0700526 friend class AudioFlinger;
Eric Laurenta553c252009-07-17 12:17:14 -0700527 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
Eric Laurent464d5b32011-06-17 21:29:58 -0700536 int mType;
Eric Laurenta553c252009-07-17 12:17:14 -0700537 Condition mWaitWorkCV;
538 sp<AudioFlinger> mAudioFlinger;
539 uint32_t mSampleRate;
540 size_t mFrameCount;
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700541 uint32_t mChannelMask;
Eric Laurentb0a01472010-05-14 05:45:46 -0700542 uint16_t mChannelCount;
543 uint16_t mFrameSize;
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700544 uint32_t mFormat;
Eric Laurenta553c252009-07-17 12:17:14 -0700545 Condition mParamCond;
Eric Laurent8fce46a2009-08-04 09:45:33 -0700546 Vector<String8> mNewParameters;
Eric Laurenta553c252009-07-17 12:17:14 -0700547 status_t mParamStatus;
548 Vector<ConfigEvent *> mConfigEvents;
549 bool mStandby;
Eric Laurent49f02be2009-11-19 09:00:56 -0800550 int mId;
551 bool mExiting;
Eric Laurent464d5b32011-06-17 21:29:58 -0700552 Vector< sp<EffectChain> > mEffectChains;
553 uint32_t mDevice; // output device for PlaybackThread
554 // input + output devices for RecordThread
Eric Laurent6dbdc402011-07-22 09:04:31 -0700555 static const int kNameLength = 32;
556 char mName[kNameLength];
557 sp<IPowerManager> mPowerManager;
558 sp<IBinder> mWakeLockToken;
559 sp<PMDeathRecipient> mDeathRecipient;
Eric Laurentf82fccd2011-07-27 19:49:51 -0700560 // list of suspended effects per session and per type. The first vector is
561 // keyed by session ID, the second by type UUID timeLow field
562 KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions;
Eric Laurenta553c252009-07-17 12:17:14 -0700563 };
564
565 // --- PlaybackThread ---
566 class PlaybackThread : public ThreadBase {
567 public:
568
Eric Laurent059b4be2009-11-09 23:32:22 -0800569 enum mixer_state {
570 MIXER_IDLE,
571 MIXER_TRACKS_ENABLED,
572 MIXER_TRACKS_READY
573 };
574
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800575 // playback track
576 class Track : public TrackBase {
577 public:
Eric Laurenta553c252009-07-17 12:17:14 -0700578 Track( const wp<ThreadBase>& thread,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800579 const sp<Client>& client,
580 int streamType,
581 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700582 uint32_t format,
583 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800584 int frameCount,
Eric Laurent65b65452010-06-01 23:49:17 -0700585 const sp<IMemory>& sharedBuffer,
586 int sessionId);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800587 ~Track();
588
589 void dump(char* buffer, size_t size);
590 virtual status_t start();
591 virtual void stop();
592 void pause();
593
594 void flush();
595 void destroy();
596 void mute(bool);
597 void setVolume(float left, float right);
Eric Laurenta553c252009-07-17 12:17:14 -0700598 int name() const {
599 return mName;
600 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800601
Eric Laurent4bc035a2009-05-22 09:18:15 -0700602 int type() const {
603 return mStreamType;
604 }
Eric Laurent65b65452010-06-01 23:49:17 -0700605 status_t attachAuxEffect(int EffectId);
606 void setAuxBuffer(int EffectId, int32_t *buffer);
607 int32_t *auxBuffer() { return mAuxBuffer; }
608 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
609 int16_t *mainBuffer() { return mMainBuffer; }
610 int auxEffectId() { return mAuxEffectId; }
Eric Laurent4bc035a2009-05-22 09:18:15 -0700611
612
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800613 protected:
Eric Laurenta553c252009-07-17 12:17:14 -0700614 friend class ThreadBase;
Eric Laurent2c817f52009-07-23 13:17:39 -0700615 friend class TrackHandle;
616 friend class PlaybackThread;
617 friend class MixerThread;
618 friend class DirectOutputThread;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800619
620 Track(const Track&);
621 Track& operator = (const Track&);
622
623 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurenta553c252009-07-17 12:17:14 -0700624 bool isMuted() { return mMute; }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800625 bool isPausing() const {
626 return mState == PAUSING;
627 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800628 bool isPaused() const {
629 return mState == PAUSED;
630 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800631 bool isReady() const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800632 void setPaused() { mState = PAUSED; }
633 void reset();
634
Eric Laurent49f02be2009-11-19 09:00:56 -0800635 bool isOutputTrack() const {
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700636 return (mStreamType == AUDIO_STREAM_CNT);
Eric Laurent49f02be2009-11-19 09:00:56 -0800637 }
638
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800639 // we don't really need a lock for these
640 float mVolume[2];
641 volatile bool mMute;
642 // FILLED state is used for suppressing volume ramp at begin of playing
643 enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
644 mutable uint8_t mFillingUpStatus;
645 int8_t mRetryCount;
646 sp<IMemory> mSharedBuffer;
647 bool mResetDone;
Eric Laurent4bc035a2009-05-22 09:18:15 -0700648 int mStreamType;
Eric Laurenta553c252009-07-17 12:17:14 -0700649 int mName;
Eric Laurent65b65452010-06-01 23:49:17 -0700650 int16_t *mMainBuffer;
651 int32_t *mAuxBuffer;
652 int mAuxEffectId;
Eric Laurenta92ebfa2010-08-31 13:50:07 -0700653 bool mHasVolumeController;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800654 }; // end of Track
655
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800656
657 // playback track
658 class OutputTrack : public Track {
659 public:
Eric Laurenta553c252009-07-17 12:17:14 -0700660
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800661 class Buffer: public AudioBufferProvider::Buffer {
662 public:
663 int16_t *mBuffer;
664 };
Eric Laurenta553c252009-07-17 12:17:14 -0700665
666 OutputTrack( const wp<ThreadBase>& thread,
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800667 DuplicatingThread *sourceThread,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800668 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700669 uint32_t format,
670 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800671 int frameCount);
672 ~OutputTrack();
673
674 virtual status_t start();
675 virtual void stop();
Eric Laurenta553c252009-07-17 12:17:14 -0700676 bool write(int16_t* data, uint32_t frames);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800677 bool bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; }
Eric Laurenta553c252009-07-17 12:17:14 -0700678 bool isActive() { return mActive; }
679 wp<ThreadBase>& thread() { return mThread; }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800680
681 private:
682
Eric Laurenta553c252009-07-17 12:17:14 -0700683 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800684 void clearBufferQueue();
Eric Laurenta553c252009-07-17 12:17:14 -0700685
686 // Maximum number of pending buffers allocated by OutputTrack::write()
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800687 static const uint8_t kMaxOverFlowBuffers = 10;
Eric Laurenta553c252009-07-17 12:17:14 -0700688
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800689 Vector < Buffer* > mBufferQueue;
690 AudioBufferProvider::Buffer mOutBuffer;
Eric Laurenta553c252009-07-17 12:17:14 -0700691 bool mActive;
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800692 DuplicatingThread* mSourceThread;
Eric Laurenta553c252009-07-17 12:17:14 -0700693 }; // end of OutputTrack
694
Dima Zavin31f188892011-04-18 16:57:27 -0700695 PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device);
Eric Laurenta553c252009-07-17 12:17:14 -0700696 virtual ~PlaybackThread();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800697
698 virtual status_t dump(int fd, const Vector<String16>& args);
699
700 // Thread virtuals
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800701 virtual status_t readyToRun();
702 virtual void onFirstRef();
703
Eric Laurent464d5b32011-06-17 21:29:58 -0700704 virtual status_t initCheck() const { return (mOutput == 0) ? NO_INIT : NO_ERROR; }
705
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800706 virtual uint32_t latency() const;
707
708 virtual status_t setMasterVolume(float value);
709 virtual status_t setMasterMute(bool muted);
710
711 virtual float masterVolume() const;
712 virtual bool masterMute() const;
713
714 virtual status_t setStreamVolume(int stream, float value);
715 virtual status_t setStreamMute(int stream, bool muted);
716
717 virtual float streamVolume(int stream) const;
718 virtual bool streamMute(int stream) const;
719
The Android Open Source Projectb2a3dd82009-03-09 11:52:12 -0700720 sp<Track> createTrack_l(
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800721 const sp<AudioFlinger::Client>& client,
722 int streamType,
723 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700724 uint32_t format,
725 uint32_t channelMask,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800726 int frameCount,
727 const sp<IMemory>& sharedBuffer,
Eric Laurent65b65452010-06-01 23:49:17 -0700728 int sessionId,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800729 status_t *status);
Eric Laurenta553c252009-07-17 12:17:14 -0700730
Eric Laurent828b9772011-08-07 16:32:26 -0700731 AudioStreamOut* getOutput();
732 AudioStreamOut* clearOutput();
733 virtual audio_stream_t* stream();
Eric Laurenta553c252009-07-17 12:17:14 -0700734
Eric Laurentd5603c12009-08-06 08:49:39 -0700735 void suspend() { mSuspended++; }
736 void restore() { if (mSuspended) mSuspended--; }
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800737 bool isSuspended() { return (mSuspended != 0); }
Eric Laurenta553c252009-07-17 12:17:14 -0700738 virtual String8 getParameters(const String8& keys);
Eric Laurenteb8f850d2010-05-14 03:26:45 -0700739 virtual void audioConfigChanged_l(int event, int param = 0);
Eric Laurent0986e792010-01-19 17:37:09 -0800740 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Eric Laurent65b65452010-06-01 23:49:17 -0700741 int16_t *mixBuffer() { return mMixBuffer; };
742
Eric Laurent464d5b32011-06-17 21:29:58 -0700743 virtual void detachAuxEffect_l(int effectId);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700744 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track,
745 int EffectId);
746 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track,
747 int EffectId);
Eric Laurenta553c252009-07-17 12:17:14 -0700748
Eric Laurent464d5b32011-06-17 21:29:58 -0700749 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
750 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
751 virtual uint32_t hasAudioSession(int sessionId);
752 virtual uint32_t getStrategyForSession_l(int sessionId);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700753
Eric Laurent05ce0942011-08-30 10:18:54 -0700754 void setStreamValid(int streamType, bool valid);
755
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800756 struct stream_type_t {
757 stream_type_t()
758 : volume(1.0f),
Eric Laurent05ce0942011-08-30 10:18:54 -0700759 mute(false),
760 valid(true)
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800761 {
762 }
763 float volume;
764 bool mute;
Eric Laurent05ce0942011-08-30 10:18:54 -0700765 bool valid;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800766 };
767
Eric Laurent2c817f52009-07-23 13:17:39 -0700768 protected:
Eric Laurent2c817f52009-07-23 13:17:39 -0700769 int16_t* mMixBuffer;
Eric Laurentd5603c12009-08-06 08:49:39 -0700770 int mSuspended;
Eric Laurent2c817f52009-07-23 13:17:39 -0700771 int mBytesWritten;
772 bool mMasterMute;
773 SortedVector< wp<Track> > mActiveTracks;
774
Eric Laurent62443f52009-10-05 20:29:18 -0700775 virtual int getTrackName_l() = 0;
776 virtual void deleteTrackName_l(int name) = 0;
Eric Laurent059b4be2009-11-09 23:32:22 -0800777 virtual uint32_t activeSleepTimeUs() = 0;
778 virtual uint32_t idleSleepTimeUs() = 0;
Eric Laurent8448a792010-08-18 18:13:17 -0700779 virtual uint32_t suspendSleepTimeUs() = 0;
Eric Laurent62443f52009-10-05 20:29:18 -0700780
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800781 private:
782
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800783 friend class AudioFlinger;
Eric Laurent6c30a712009-08-10 23:22:32 -0700784 friend class OutputTrack;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800785 friend class Track;
786 friend class TrackBase;
Eric Laurenta553c252009-07-17 12:17:14 -0700787 friend class MixerThread;
788 friend class DirectOutputThread;
789 friend class DuplicatingThread;
790
791 PlaybackThread(const Client&);
792 PlaybackThread& operator = (const PlaybackThread&);
793
The Android Open Source Projectb2a3dd82009-03-09 11:52:12 -0700794 status_t addTrack_l(const sp<Track>& track);
The Android Open Source Projectb2a3dd82009-03-09 11:52:12 -0700795 void destroyTrack_l(const sp<Track>& track);
Eric Laurent90681d62011-05-09 12:09:06 -0700796 void removeTrack_l(const sp<Track>& track);
Eric Laurent62443f52009-10-05 20:29:18 -0700797
Eric Laurenta553c252009-07-17 12:17:14 -0700798 void readOutputParameters();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800799
Eric Laurenta553c252009-07-17 12:17:14 -0700800 virtual status_t dumpInternals(int fd, const Vector<String16>& args);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800801 status_t dumpTracks(int fd, const Vector<String16>& args);
Eric Laurenta553c252009-07-17 12:17:14 -0700802
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800803 SortedVector< sp<Track> > mTracks;
Eric Laurenta553c252009-07-17 12:17:14 -0700804 // mStreamTypes[] uses 1 additionnal stream type internally for the OutputTrack used by DuplicatingThread
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700805 stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1];
Dima Zavin31f188892011-04-18 16:57:27 -0700806 AudioStreamOut* mOutput;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800807 float mMasterVolume;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800808 nsecs_t mLastWriteTime;
809 int mNumWrites;
810 int mNumDelayedWrites;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800811 bool mInWrite;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800812 };
813
Eric Laurenta553c252009-07-17 12:17:14 -0700814 class MixerThread : public PlaybackThread {
815 public:
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700816 MixerThread (const sp<AudioFlinger>& audioFlinger,
Dima Zavin31f188892011-04-18 16:57:27 -0700817 AudioStreamOut* output,
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700818 int id,
819 uint32_t device);
Eric Laurenta553c252009-07-17 12:17:14 -0700820 virtual ~MixerThread();
821
822 // Thread virtuals
823 virtual bool threadLoop();
824
Eric Laurenteb8f850d2010-05-14 03:26:45 -0700825 void invalidateTracks(int streamType);
Eric Laurenta553c252009-07-17 12:17:14 -0700826 virtual bool checkForNewParameters_l();
827 virtual status_t dumpInternals(int fd, const Vector<String16>& args);
828
829 protected:
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700830 uint32_t prepareTracks_l(const SortedVector< wp<Track> >& activeTracks,
831 Vector< sp<Track> > *tracksToRemove);
Eric Laurent62443f52009-10-05 20:29:18 -0700832 virtual int getTrackName_l();
833 virtual void deleteTrackName_l(int name);
Eric Laurent059b4be2009-11-09 23:32:22 -0800834 virtual uint32_t activeSleepTimeUs();
835 virtual uint32_t idleSleepTimeUs();
Eric Laurent8448a792010-08-18 18:13:17 -0700836 virtual uint32_t suspendSleepTimeUs();
Eric Laurenta553c252009-07-17 12:17:14 -0700837
838 AudioMixer* mAudioMixer;
839 };
840
841 class DirectOutputThread : public PlaybackThread {
842 public:
843
Dima Zavin31f188892011-04-18 16:57:27 -0700844 DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device);
Eric Laurenta553c252009-07-17 12:17:14 -0700845 ~DirectOutputThread();
846
847 // Thread virtuals
848 virtual bool threadLoop();
849
Eric Laurent62443f52009-10-05 20:29:18 -0700850 virtual bool checkForNewParameters_l();
851
852 protected:
Eric Laurenta553c252009-07-17 12:17:14 -0700853 virtual int getTrackName_l();
854 virtual void deleteTrackName_l(int name);
Eric Laurent059b4be2009-11-09 23:32:22 -0800855 virtual uint32_t activeSleepTimeUs();
856 virtual uint32_t idleSleepTimeUs();
Eric Laurent8448a792010-08-18 18:13:17 -0700857 virtual uint32_t suspendSleepTimeUs();
Eric Laurenta553c252009-07-17 12:17:14 -0700858
859 private:
Eric Laurent65b65452010-06-01 23:49:17 -0700860 void applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp);
861
862 float mLeftVolFloat;
863 float mRightVolFloat;
864 uint16_t mLeftVolShort;
865 uint16_t mRightVolShort;
Eric Laurenta553c252009-07-17 12:17:14 -0700866 };
867
868 class DuplicatingThread : public MixerThread {
869 public:
Eric Laurent49f02be2009-11-19 09:00:56 -0800870 DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, int id);
Eric Laurenta553c252009-07-17 12:17:14 -0700871 ~DuplicatingThread();
872
873 // Thread virtuals
874 virtual bool threadLoop();
875 void addOutputTrack(MixerThread* thread);
876 void removeOutputTrack(MixerThread* thread);
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800877 uint32_t waitTimeMs() { return mWaitTimeMs; }
878 protected:
879 virtual uint32_t activeSleepTimeUs();
Eric Laurenta553c252009-07-17 12:17:14 -0700880
881 private:
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800882 bool outputsReady(SortedVector< sp<OutputTrack> > &outputTracks);
883 void updateWaitTime();
884
Eric Laurenta553c252009-07-17 12:17:14 -0700885 SortedVector < sp<OutputTrack> > mOutputTracks;
Eric Laurent8ac9f8d2009-12-18 05:47:48 -0800886 uint32_t mWaitTimeMs;
Eric Laurenta553c252009-07-17 12:17:14 -0700887 };
888
Eric Laurentddb78e72009-07-28 08:44:33 -0700889 PlaybackThread *checkPlaybackThread_l(int output) const;
890 MixerThread *checkMixerThread_l(int output) const;
891 RecordThread *checkRecordThread_l(int input) const;
Eric Laurenta553c252009-07-17 12:17:14 -0700892 float streamVolumeInternal(int stream) const { return mStreamTypes[stream].volume; }
Eric Laurent49f02be2009-11-19 09:00:56 -0800893 void audioConfigChanged_l(int event, int ioHandle, void *param2);
Eric Laurenta553c252009-07-17 12:17:14 -0700894
Eric Laurent464d5b32011-06-17 21:29:58 -0700895 uint32_t nextUniqueId();
Eric Laurentf82fccd2011-07-27 19:49:51 -0700896 status_t moveEffectChain_l(int sessionId,
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700897 AudioFlinger::PlaybackThread *srcThread,
Eric Laurent493941b2010-07-28 01:32:47 -0700898 AudioFlinger::PlaybackThread *dstThread,
899 bool reRegister);
Eric Laurent464d5b32011-06-17 21:29:58 -0700900 PlaybackThread *primaryPlaybackThread_l();
901 uint32_t primaryOutputDevice_l();
Eric Laurent65b65452010-06-01 23:49:17 -0700902
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800903 friend class AudioBuffer;
904
905 class TrackHandle : public android::BnAudioTrack {
906 public:
Eric Laurenta553c252009-07-17 12:17:14 -0700907 TrackHandle(const sp<PlaybackThread::Track>& track);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800908 virtual ~TrackHandle();
909 virtual status_t start();
910 virtual void stop();
911 virtual void flush();
912 virtual void mute(bool);
913 virtual void pause();
914 virtual void setVolume(float left, float right);
915 virtual sp<IMemory> getCblk() const;
Eric Laurent65b65452010-06-01 23:49:17 -0700916 virtual status_t attachAuxEffect(int effectId);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800917 virtual status_t onTransact(
918 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
919 private:
Eric Laurenta553c252009-07-17 12:17:14 -0700920 sp<PlaybackThread::Track> mTrack;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800921 };
922
923 friend class Client;
Eric Laurenta553c252009-07-17 12:17:14 -0700924 friend class PlaybackThread::Track;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800925
926
Eric Laurentb9481d82009-09-17 05:12:56 -0700927 void removeClient_l(pid_t pid);
Eric Laurent4f0f17d2010-05-12 02:05:53 -0700928 void removeNotificationClient(pid_t pid);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800929
930
Eric Laurenta553c252009-07-17 12:17:14 -0700931 // record thread
932 class RecordThread : public ThreadBase, public AudioBufferProvider
933 {
934 public:
935
936 // record track
937 class RecordTrack : public TrackBase {
938 public:
939 RecordTrack(const wp<ThreadBase>& thread,
940 const sp<Client>& client,
941 uint32_t sampleRate,
Jean-Michel Trivi54392232011-05-24 15:53:33 -0700942 uint32_t format,
943 uint32_t channelMask,
Eric Laurenta553c252009-07-17 12:17:14 -0700944 int frameCount,
Eric Laurent65b65452010-06-01 23:49:17 -0700945 uint32_t flags,
946 int sessionId);
Eric Laurenta553c252009-07-17 12:17:14 -0700947 ~RecordTrack();
948
949 virtual status_t start();
950 virtual void stop();
951
952 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
953 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
954
Eric Laurent3fdb1262009-11-07 00:01:32 -0800955 void dump(char* buffer, size_t size);
Eric Laurentf82fccd2011-07-27 19:49:51 -0700956
Eric Laurenta553c252009-07-17 12:17:14 -0700957 private:
958 friend class AudioFlinger;
Eric Laurent2c817f52009-07-23 13:17:39 -0700959 friend class RecordThread;
Eric Laurenta553c252009-07-17 12:17:14 -0700960
961 RecordTrack(const RecordTrack&);
962 RecordTrack& operator = (const RecordTrack&);
963
964 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
965
966 bool mOverflow;
967 };
968
969
970 RecordThread(const sp<AudioFlinger>& audioFlinger,
Dima Zavin31f188892011-04-18 16:57:27 -0700971 AudioStreamIn *input,
Eric Laurenta553c252009-07-17 12:17:14 -0700972 uint32_t sampleRate,
Eric Laurent49f02be2009-11-19 09:00:56 -0800973 uint32_t channels,
Eric Laurent464d5b32011-06-17 21:29:58 -0700974 int id,
975 uint32_t device);
Eric Laurenta553c252009-07-17 12:17:14 -0700976 ~RecordThread();
977
978 virtual bool threadLoop();
Eric Laurent828b9772011-08-07 16:32:26 -0700979 virtual status_t readyToRun();
Eric Laurenta553c252009-07-17 12:17:14 -0700980 virtual void onFirstRef();
981
Eric Laurent464d5b32011-06-17 21:29:58 -0700982 virtual status_t initCheck() const { return (mInput == 0) ? NO_INIT : NO_ERROR; }
983 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
984 const sp<AudioFlinger::Client>& client,
985 uint32_t sampleRate,
986 int format,
987 int channelMask,
988 int frameCount,
989 uint32_t flags,
990 int sessionId,
991 status_t *status);
992
Eric Laurenta553c252009-07-17 12:17:14 -0700993 status_t start(RecordTrack* recordTrack);
994 void stop(RecordTrack* recordTrack);
995 status_t dump(int fd, const Vector<String16>& args);
Eric Laurent828b9772011-08-07 16:32:26 -0700996 AudioStreamIn* getInput();
997 AudioStreamIn* clearInput();
998 virtual audio_stream_t* stream();
Eric Laurenta553c252009-07-17 12:17:14 -0700999
1000 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
1001 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
1002 virtual bool checkForNewParameters_l();
1003 virtual String8 getParameters(const String8& keys);
Eric Laurenteb8f850d2010-05-14 03:26:45 -07001004 virtual void audioConfigChanged_l(int event, int param = 0);
Eric Laurenta553c252009-07-17 12:17:14 -07001005 void readInputParameters();
Eric Laurent47d0a922010-02-26 02:47:27 -08001006 virtual unsigned int getInputFramesLost();
Eric Laurenta553c252009-07-17 12:17:14 -07001007
Eric Laurent464d5b32011-06-17 21:29:58 -07001008 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1009 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
1010 virtual uint32_t hasAudioSession(int sessionId);
Eric Laurent6639b552011-08-01 09:52:20 -07001011 RecordTrack* track();
Eric Laurent464d5b32011-06-17 21:29:58 -07001012
Eric Laurenta553c252009-07-17 12:17:14 -07001013 private:
1014 RecordThread();
Dima Zavin31f188892011-04-18 16:57:27 -07001015 AudioStreamIn *mInput;
Eric Laurent464d5b32011-06-17 21:29:58 -07001016 RecordTrack* mTrack;
Eric Laurenta553c252009-07-17 12:17:14 -07001017 sp<RecordTrack> mActiveTrack;
1018 Condition mStartStopCond;
1019 AudioResampler *mResampler;
1020 int32_t *mRsmpOutBuffer;
1021 int16_t *mRsmpInBuffer;
1022 size_t mRsmpInIndex;
1023 size_t mInputBytes;
1024 int mReqChannelCount;
1025 uint32_t mReqSampleRate;
Eric Laurent9cc489a22009-12-05 05:20:01 -08001026 ssize_t mBytesRead;
Eric Laurenta553c252009-07-17 12:17:14 -07001027 };
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001028
1029 class RecordHandle : public android::BnAudioRecord {
1030 public:
Eric Laurenta553c252009-07-17 12:17:14 -07001031 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001032 virtual ~RecordHandle();
1033 virtual status_t start();
1034 virtual void stop();
1035 virtual sp<IMemory> getCblk() const;
1036 virtual status_t onTransact(
1037 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
1038 private:
Eric Laurenta553c252009-07-17 12:17:14 -07001039 sp<RecordThread::RecordTrack> mRecordTrack;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001040 };
1041
Eric Laurent65b65452010-06-01 23:49:17 -07001042 //--- Audio Effect Management
1043
1044 // EffectModule and EffectChain classes both have their own mutex to protect
1045 // state changes or resource modifications. Always respect the following order
1046 // if multiple mutexes must be acquired to avoid cross deadlock:
1047 // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule
1048
1049 // The EffectModule class is a wrapper object controlling the effect engine implementation
1050 // in the effect library. It prevents concurrent calls to process() and command() functions
1051 // from different client threads. It keeps a list of EffectHandle objects corresponding
1052 // to all client applications using this effect and notifies applications of effect state,
1053 // control or parameter changes. It manages the activation state machine to send appropriate
1054 // reset, enable, disable commands to effect engine and provide volume
1055 // ramping when effects are activated/deactivated.
1056 // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by
1057 // the attached track(s) to accumulate their auxiliary channel.
1058 class EffectModule: public RefBase {
1059 public:
1060 EffectModule(const wp<ThreadBase>& wThread,
1061 const wp<AudioFlinger::EffectChain>& chain,
1062 effect_descriptor_t *desc,
1063 int id,
1064 int sessionId);
1065 ~EffectModule();
1066
1067 enum effect_state {
1068 IDLE,
Eric Laurent7d850f22010-07-09 13:34:17 -07001069 RESTART,
Eric Laurent65b65452010-06-01 23:49:17 -07001070 STARTING,
1071 ACTIVE,
1072 STOPPING,
Eric Laurent21b5c472011-07-26 20:54:46 -07001073 STOPPED,
1074 DESTROYED
Eric Laurent65b65452010-06-01 23:49:17 -07001075 };
1076
1077 int id() { return mId; }
1078 void process();
Eric Laurent7d850f22010-07-09 13:34:17 -07001079 void updateState();
Eric Laurenta4c72ac2010-07-28 05:40:18 -07001080 status_t command(uint32_t cmdCode,
1081 uint32_t cmdSize,
1082 void *pCmdData,
1083 uint32_t *replySize,
1084 void *pReplyData);
Eric Laurent65b65452010-06-01 23:49:17 -07001085
Eric Laurentdf9b81c2010-07-02 08:12:41 -07001086 void reset_l();
Eric Laurent65b65452010-06-01 23:49:17 -07001087 status_t configure();
1088 status_t init();
1089 uint32_t state() {
1090 return mState;
1091 }
1092 uint32_t status() {
1093 return mStatus;
1094 }
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001095 int sessionId() {
1096 return mSessionId;
1097 }
Eric Laurent65b65452010-06-01 23:49:17 -07001098 status_t setEnabled(bool enabled);
1099 bool isEnabled();
Eric Laurenta92ebfa2010-08-31 13:50:07 -07001100 bool isProcessEnabled();
Eric Laurent65b65452010-06-01 23:49:17 -07001101
1102 void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; }
1103 int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; }
1104 void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; }
1105 int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; }
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001106 void setChain(const wp<EffectChain>& chain) { mChain = chain; }
1107 void setThread(const wp<ThreadBase>& thread) { mThread = thread; }
Eric Laurentf82fccd2011-07-27 19:49:51 -07001108 wp<ThreadBase>& thread() { return mThread; }
Eric Laurent65b65452010-06-01 23:49:17 -07001109
1110 status_t addHandle(sp<EffectHandle>& handle);
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001111 void disconnect(const wp<EffectHandle>& handle, bool unpiniflast);
Eric Laurent65b65452010-06-01 23:49:17 -07001112 size_t removeHandle (const wp<EffectHandle>& handle);
1113
1114 effect_descriptor_t& desc() { return mDescriptor; }
Eric Laurent53334cd2010-06-23 17:38:20 -07001115 wp<EffectChain>& chain() { return mChain; }
Eric Laurent65b65452010-06-01 23:49:17 -07001116
1117 status_t setDevice(uint32_t device);
1118 status_t setVolume(uint32_t *left, uint32_t *right, bool controller);
Eric Laurent53334cd2010-06-23 17:38:20 -07001119 status_t setMode(uint32_t mode);
Eric Laurent21b5c472011-07-26 20:54:46 -07001120 status_t stop();
Eric Laurentf82fccd2011-07-27 19:49:51 -07001121 void setSuspended(bool suspended);
1122 bool suspended();
1123
1124 sp<EffectHandle> controlHandle();
Eric Laurent65b65452010-06-01 23:49:17 -07001125
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001126 bool isPinned() { return mPinned; }
1127 void unPin() { mPinned = false; }
1128
Eric Laurent65b65452010-06-01 23:49:17 -07001129 status_t dump(int fd, const Vector<String16>& args);
1130
1131 protected:
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001132 friend class EffectHandle;
1133 friend class AudioFlinger;
1134 bool mPinned;
Eric Laurent65b65452010-06-01 23:49:17 -07001135
Eric Laurent7d850f22010-07-09 13:34:17 -07001136 // Maximum time allocated to effect engines to complete the turn off sequence
1137 static const uint32_t MAX_DISABLE_TIME_MS = 10000;
1138
Eric Laurent65b65452010-06-01 23:49:17 -07001139 EffectModule(const EffectModule&);
1140 EffectModule& operator = (const EffectModule&);
1141
Eric Laurentdf9b81c2010-07-02 08:12:41 -07001142 status_t start_l();
1143 status_t stop_l();
Eric Laurent65b65452010-06-01 23:49:17 -07001144
1145 Mutex mLock; // mutex for process, commands and handles list protection
1146 wp<ThreadBase> mThread; // parent thread
1147 wp<EffectChain> mChain; // parent effect chain
1148 int mId; // this instance unique ID
1149 int mSessionId; // audio session ID
1150 effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
1151 effect_config_t mConfig; // input and output audio configuration
Eric Laurent0fb66c22011-05-17 19:16:02 -07001152 effect_handle_t mEffectInterface; // Effect module C API
Eric Laurent65b65452010-06-01 23:49:17 -07001153 status_t mStatus; // initialization status
1154 uint32_t mState; // current activation state (effect_state)
1155 Vector< wp<EffectHandle> > mHandles; // list of client handles
Eric Laurent7d850f22010-07-09 13:34:17 -07001156 uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after
1157 // sending disable command.
1158 uint32_t mDisableWaitCnt; // current process() calls count during disable period.
Eric Laurentf82fccd2011-07-27 19:49:51 -07001159 bool mSuspended; // effect is suspended: temporarily disabled by framework
Eric Laurent65b65452010-06-01 23:49:17 -07001160 };
1161
1162 // The EffectHandle class implements the IEffect interface. It provides resources
1163 // to receive parameter updates, keeps track of effect control
1164 // ownership and state and has a pointer to the EffectModule object it is controlling.
1165 // There is one EffectHandle object for each application controlling (or using)
1166 // an effect module.
1167 // The EffectHandle is obtained by calling AudioFlinger::createEffect().
1168 class EffectHandle: public android::BnEffect {
1169 public:
1170
1171 EffectHandle(const sp<EffectModule>& effect,
1172 const sp<AudioFlinger::Client>& client,
1173 const sp<IEffectClient>& effectClient,
1174 int32_t priority);
1175 virtual ~EffectHandle();
1176
1177 // IEffect
1178 virtual status_t enable();
1179 virtual status_t disable();
Eric Laurenta4c72ac2010-07-28 05:40:18 -07001180 virtual status_t command(uint32_t cmdCode,
1181 uint32_t cmdSize,
1182 void *pCmdData,
1183 uint32_t *replySize,
1184 void *pReplyData);
Eric Laurent65b65452010-06-01 23:49:17 -07001185 virtual void disconnect();
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001186 virtual void disconnect(bool unpiniflast);
Eric Laurent65b65452010-06-01 23:49:17 -07001187 virtual sp<IMemory> getCblk() const;
1188 virtual status_t onTransact(uint32_t code, const Parcel& data,
1189 Parcel* reply, uint32_t flags);
1190
1191
1192 // Give or take control of effect module
Eric Laurentf82fccd2011-07-27 19:49:51 -07001193 // - hasControl: true if control is given, false if removed
1194 // - signal: true client app should be signaled of change, false otherwise
1195 // - enabled: state of the effect when control is passed
1196 void setControl(bool hasControl, bool signal, bool enabled);
Eric Laurenta4c72ac2010-07-28 05:40:18 -07001197 void commandExecuted(uint32_t cmdCode,
1198 uint32_t cmdSize,
1199 void *pCmdData,
1200 uint32_t replySize,
1201 void *pReplyData);
Eric Laurent65b65452010-06-01 23:49:17 -07001202 void setEnabled(bool enabled);
Eric Laurentf82fccd2011-07-27 19:49:51 -07001203 bool enabled() { return mEnabled; }
Eric Laurent65b65452010-06-01 23:49:17 -07001204
1205 // Getters
1206 int id() { return mEffect->id(); }
1207 int priority() { return mPriority; }
1208 bool hasControl() { return mHasControl; }
1209 sp<EffectModule> effect() { return mEffect; }
1210
1211 void dump(char* buffer, size_t size);
1212
1213 protected:
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001214 friend class AudioFlinger;
1215 friend class EffectModule;
Eric Laurent65b65452010-06-01 23:49:17 -07001216 EffectHandle(const EffectHandle&);
1217 EffectHandle& operator =(const EffectHandle&);
1218
1219 sp<EffectModule> mEffect; // pointer to controlled EffectModule
1220 sp<IEffectClient> mEffectClient; // callback interface for client notifications
1221 sp<Client> mClient; // client for shared memory allocation
1222 sp<IMemory> mCblkMemory; // shared memory for control block
1223 effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory
1224 uint8_t* mBuffer; // pointer to parameter area in shared memory
1225 int mPriority; // client application priority to control the effect
1226 bool mHasControl; // true if this handle is controlling the effect
Eric Laurentf82fccd2011-07-27 19:49:51 -07001227 bool mEnabled; // cached enable state: needed when the effect is
1228 // restored after being suspended
Eric Laurent65b65452010-06-01 23:49:17 -07001229 };
1230
1231 // the EffectChain class represents a group of effects associated to one audio session.
1232 // There can be any number of EffectChain objects per output mixer thread (PlaybackThread).
1233 // The EffecChain with session ID 0 contains global effects applied to the output mix.
1234 // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks)
1235 // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding
1236 // in the effect process order. When attached to a track (session ID != 0), it also provide it's own
1237 // input buffer used by the track as accumulation buffer.
1238 class EffectChain: public RefBase {
1239 public:
1240 EffectChain(const wp<ThreadBase>& wThread, int sessionId);
1241 ~EffectChain();
1242
Eric Laurentf82fccd2011-07-27 19:49:51 -07001243 // special key used for an entry in mSuspendedEffects keyed vector
1244 // corresponding to a suspend all request.
1245 static const int kKeyForSuspendAll = 0;
1246
Eric Laurent65b65452010-06-01 23:49:17 -07001247 void process_l();
1248
1249 void lock() {
1250 mLock.lock();
1251 }
1252 void unlock() {
1253 mLock.unlock();
1254 }
1255
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001256 status_t addEffect_l(const sp<EffectModule>& handle);
Eric Laurent76c40f72010-07-15 12:50:15 -07001257 size_t removeEffect_l(const sp<EffectModule>& handle);
Eric Laurent65b65452010-06-01 23:49:17 -07001258
Eric Laurent464d5b32011-06-17 21:29:58 -07001259 int sessionId() { return mSessionId; }
1260 void setSessionId(int sessionId) { mSessionId = sessionId; }
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001261
Eric Laurent76c40f72010-07-15 12:50:15 -07001262 sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor);
1263 sp<EffectModule> getEffectFromId_l(int id);
Eric Laurentf82fccd2011-07-27 19:49:51 -07001264 sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type);
Eric Laurent76c40f72010-07-15 12:50:15 -07001265 bool setVolume_l(uint32_t *left, uint32_t *right);
1266 void setDevice_l(uint32_t device);
1267 void setMode_l(uint32_t mode);
Eric Laurent53334cd2010-06-23 17:38:20 -07001268
Eric Laurent65b65452010-06-01 23:49:17 -07001269 void setInBuffer(int16_t *buffer, bool ownsBuffer = false) {
1270 mInBuffer = buffer;
1271 mOwnInBuffer = ownsBuffer;
1272 }
1273 int16_t *inBuffer() {
1274 return mInBuffer;
1275 }
1276 void setOutBuffer(int16_t *buffer) {
1277 mOutBuffer = buffer;
1278 }
1279 int16_t *outBuffer() {
1280 return mOutBuffer;
1281 }
1282
Eric Laurent90681d62011-05-09 12:09:06 -07001283 void incTrackCnt() { android_atomic_inc(&mTrackCnt); }
1284 void decTrackCnt() { android_atomic_dec(&mTrackCnt); }
1285 int32_t trackCnt() { return mTrackCnt;}
1286
1287 void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt); }
1288 void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
1289 int32_t activeTrackCnt() { return mActiveTrackCnt;}
Eric Laurent65b65452010-06-01 23:49:17 -07001290
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001291 uint32_t strategy() { return mStrategy; }
1292 void setStrategy(uint32_t strategy)
1293 { mStrategy = strategy; }
1294
Eric Laurentf82fccd2011-07-27 19:49:51 -07001295 // suspend effect of the given type
1296 void setEffectSuspended_l(const effect_uuid_t *type,
1297 bool suspend);
1298 // suspend all eligible effects
1299 void setEffectSuspendedAll_l(bool suspend);
1300 // check if effects should be suspend or restored when a given effect is enable or disabled
1301 virtual void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
1302 bool enabled);
1303
Eric Laurent65b65452010-06-01 23:49:17 -07001304 status_t dump(int fd, const Vector<String16>& args);
1305
1306 protected:
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001307 friend class AudioFlinger;
Eric Laurent65b65452010-06-01 23:49:17 -07001308 EffectChain(const EffectChain&);
1309 EffectChain& operator =(const EffectChain&);
1310
Eric Laurentf82fccd2011-07-27 19:49:51 -07001311 class SuspendedEffectDesc : public RefBase {
1312 public:
1313 SuspendedEffectDesc() : mRefCount(0) {}
1314
1315 int mRefCount;
1316 effect_uuid_t mType;
1317 wp<EffectModule> mEffect;
1318 };
1319
1320 // get a list of effect modules to suspend when an effect of the type
1321 // passed is enabled.
1322 Vector< sp<EffectModule> > getSuspendEligibleEffects();
1323 // get an effect module if it is currently enable
1324 sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type);
Eric Laurent6752ec82011-08-10 10:37:50 -07001325 // true if the effect whose descriptor is passed can be suspended
1326 // OEMs can modify the rules implemented in this method to exclude specific effect
1327 // types or implementations from the suspend/restore mechanism.
1328 bool isEffectEligibleForSuspend(const effect_descriptor_t& desc);
Eric Laurentf82fccd2011-07-27 19:49:51 -07001329
Eric Laurent65b65452010-06-01 23:49:17 -07001330 wp<ThreadBase> mThread; // parent mixer thread
1331 Mutex mLock; // mutex protecting effect list
1332 Vector<sp<EffectModule> > mEffects; // list of effect modules
1333 int mSessionId; // audio session ID
1334 int16_t *mInBuffer; // chain input buffer
1335 int16_t *mOutBuffer; // chain output buffer
Eric Laurent90681d62011-05-09 12:09:06 -07001336 volatile int32_t mActiveTrackCnt; // number of active tracks connected
1337 volatile int32_t mTrackCnt; // number of tracks connected
Eric Laurent65b65452010-06-01 23:49:17 -07001338 bool mOwnInBuffer; // true if the chain owns its input buffer
Eric Laurent76c40f72010-07-15 12:50:15 -07001339 int mVolumeCtrlIdx; // index of insert effect having control over volume
1340 uint32_t mLeftVolume; // previous volume on left channel
1341 uint32_t mRightVolume; // previous volume on right channel
Eric Laurent0d7e0482010-07-19 06:24:46 -07001342 uint32_t mNewLeftVolume; // new volume on left channel
1343 uint32_t mNewRightVolume; // new volume on right channel
Eric Laurent8ed6ed02010-07-13 04:45:46 -07001344 uint32_t mStrategy; // strategy for this effect chain
Eric Laurentf82fccd2011-07-27 19:49:51 -07001345 // mSuspendedEffects lists all effect currently suspended in the chain
1346 // use effect type UUID timelow field as key. There is no real risk of identical
1347 // timeLow fields among effect type UUIDs.
1348 KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects;
Eric Laurent65b65452010-06-01 23:49:17 -07001349 };
1350
Dima Zavin31f188892011-04-18 16:57:27 -07001351 struct AudioStreamOut {
1352 audio_hw_device_t *hwDev;
1353 audio_stream_out_t *stream;
1354
1355 AudioStreamOut(audio_hw_device_t *dev, audio_stream_out_t *out) :
1356 hwDev(dev), stream(out) {}
1357 };
1358
1359 struct AudioStreamIn {
1360 audio_hw_device_t *hwDev;
1361 audio_stream_in_t *stream;
1362
1363 AudioStreamIn(audio_hw_device_t *dev, audio_stream_in_t *in) :
1364 hwDev(dev), stream(in) {}
1365 };
1366
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001367 struct AudioSessionRef {
1368 int sessionid;
1369 pid_t pid;
1370 int cnt;
1371 };
1372
Eric Laurenta553c252009-07-17 12:17:14 -07001373 friend class RecordThread;
1374 friend class PlaybackThread;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001375
The Android Open Source Projectb2a3dd82009-03-09 11:52:12 -07001376 mutable Mutex mLock;
The Android Open Source Projectb2a3dd82009-03-09 11:52:12 -07001377
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001378 DefaultKeyedVector< pid_t, wp<Client> > mClients;
1379
Eric Laurenta553c252009-07-17 12:17:14 -07001380 mutable Mutex mHardwareLock;
Dima Zavin31f188892011-04-18 16:57:27 -07001381 audio_hw_device_t* mPrimaryHardwareDev;
1382 Vector<audio_hw_device_t*> mAudioHwDevs;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001383 mutable int mHardwareStatus;
The Android Open Source Projectc39a6e02009-03-11 12:11:56 -07001384
Eric Laurenta553c252009-07-17 12:17:14 -07001385
Eric Laurentddb78e72009-07-28 08:44:33 -07001386 DefaultKeyedVector< int, sp<PlaybackThread> > mPlaybackThreads;
Dima Zavin24fc2fb2011-04-19 22:30:36 -07001387 PlaybackThread::stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurenta553c252009-07-17 12:17:14 -07001388 float mMasterVolume;
1389 bool mMasterMute;
1390
Eric Laurentddb78e72009-07-28 08:44:33 -07001391 DefaultKeyedVector< int, sp<RecordThread> > mRecordThreads;
Eric Laurenta553c252009-07-17 12:17:14 -07001392
Eric Laurent4f0f17d2010-05-12 02:05:53 -07001393 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Eric Laurent65b65452010-06-01 23:49:17 -07001394 volatile int32_t mNextUniqueId;
Eric Laurent6639b552011-08-01 09:52:20 -07001395 uint32_t mMode;
Eric Laurent2d95dfb2011-08-29 12:42:48 -07001396 bool mBtNrecIsOff;
Eric Laurent53334cd2010-06-23 17:38:20 -07001397
Marco Nelissenc74b93f2011-08-02 13:33:41 -07001398 Vector<AudioSessionRef*> mAudioSessionRefs;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001399};
1400
Dima Zavin31f188892011-04-18 16:57:27 -07001401
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001402// ----------------------------------------------------------------------------
1403
1404}; // namespace android
1405
1406#endif // ANDROID_AUDIO_FLINGER_H