blob: 7fc6cc287fc987e6c37595dd9d500eea459b058b [file] [log] [blame]
Glenn Kasten99e53b82012-01-19 08:59:58 -08001/*
Mathias Agopian65ab4712010-07-14 17:59:35 -07002**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef ANDROID_AUDIO_FLINGER_H
19#define ANDROID_AUDIO_FLINGER_H
20
21#include <stdint.h>
22#include <sys/types.h>
23#include <limits.h>
24
John Grossman4ff14ba2012-02-08 16:37:41 -080025#include <common_time/cc_helper.h>
26
Mathias Agopian65ab4712010-07-14 17:59:35 -070027#include <media/IAudioFlinger.h>
28#include <media/IAudioFlingerClient.h>
29#include <media/IAudioTrack.h>
30#include <media/IAudioRecord.h>
Glenn Kasten335787f2012-01-20 17:00:00 -080031#include <media/AudioSystem.h>
John Grossman4ff14ba2012-02-08 16:37:41 -080032#include <media/AudioTrack.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070033
34#include <utils/Atomic.h>
35#include <utils/Errors.h>
36#include <utils/threads.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070037#include <utils/SortedVector.h>
Dima Zavin799a70e2011-04-18 16:57:27 -070038#include <utils/TypeHelpers.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070039#include <utils/Vector.h>
40
Mathias Agopian5462fc92010-07-14 18:41:18 -070041#include <binder/BinderService.h>
42#include <binder/MemoryDealer.h>
43
Dima Zavin64760242011-05-11 14:15:23 -070044#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070045#include <hardware/audio.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070046
47#include "AudioBufferProvider.h"
48
Eric Laurentfeb0db62011-07-22 09:04:31 -070049#include <powermanager/IPowerManager.h>
50
Mathias Agopian65ab4712010-07-14 17:59:35 -070051namespace android {
52
53class audio_track_cblk_t;
54class effect_param_cblk_t;
55class AudioMixer;
56class AudioBuffer;
57class AudioResampler;
58
Mathias Agopian65ab4712010-07-14 17:59:35 -070059// ----------------------------------------------------------------------------
60
John Grossman4ff14ba2012-02-08 16:37:41 -080061static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
Mathias Agopian65ab4712010-07-14 17:59:35 -070062
Mathias Agopian5462fc92010-07-14 18:41:18 -070063class AudioFlinger :
64 public BinderService<AudioFlinger>,
65 public BnAudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -070066{
Mathias Agopian5462fc92010-07-14 18:41:18 -070067 friend class BinderService<AudioFlinger>;
Mathias Agopian65ab4712010-07-14 17:59:35 -070068public:
Glenn Kasten54c3b662012-01-06 07:46:30 -080069 static const char* getServiceName() { return "media.audio_flinger"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -070070
71 virtual status_t dump(int fd, const Vector<String16>& args);
72
Glenn Kasten2f732eb2012-01-26 09:48:03 -080073 // IAudioFlinger interface, in binder opcode order
Mathias Agopian65ab4712010-07-14 17:59:35 -070074 virtual sp<IAudioTrack> createTrack(
75 pid_t pid,
Glenn Kastenfff6d712012-01-12 16:38:12 -080076 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -070077 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -080078 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -070079 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -070080 int frameCount,
81 uint32_t flags,
82 const sp<IMemory>& sharedBuffer,
Glenn Kasten72ef00d2012-01-17 11:09:42 -080083 audio_io_handle_t output,
John Grossman4ff14ba2012-02-08 16:37:41 -080084 bool isTimed,
Mathias Agopian65ab4712010-07-14 17:59:35 -070085 int *sessionId,
86 status_t *status);
87
Glenn Kasten2f732eb2012-01-26 09:48:03 -080088 virtual sp<IAudioRecord> openRecord(
89 pid_t pid,
90 audio_io_handle_t input,
91 uint32_t sampleRate,
92 audio_format_t format,
93 uint32_t channelMask,
94 int frameCount,
95 uint32_t flags,
96 int *sessionId,
97 status_t *status);
98
Glenn Kasten72ef00d2012-01-17 11:09:42 -080099 virtual uint32_t sampleRate(audio_io_handle_t output) const;
100 virtual int channelCount(audio_io_handle_t output) const;
101 virtual audio_format_t format(audio_io_handle_t output) const;
102 virtual size_t frameCount(audio_io_handle_t output) const;
103 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700104
105 virtual status_t setMasterVolume(float value);
106 virtual status_t setMasterMute(bool muted);
107
108 virtual float masterVolume() const;
John Grossman4ff14ba2012-02-08 16:37:41 -0800109 virtual float masterVolumeSW() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700110 virtual bool masterMute() const;
111
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800112 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
113 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800114 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700115
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800116 virtual float streamVolume(audio_stream_type_t stream,
117 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800118 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700119
Glenn Kastenf78aee72012-01-04 11:00:47 -0800120 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700121
122 virtual status_t setMicMute(bool state);
123 virtual bool getMicMute() const;
124
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800125 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
126 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700127
128 virtual void registerClient(const sp<IAudioFlingerClient>& client);
129
Glenn Kastenf587ba52012-01-26 16:25:10 -0800130 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700131
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800132 virtual audio_io_handle_t openOutput(uint32_t *pDevices,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700133 uint32_t *pSamplingRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800134 audio_format_t *pFormat,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700135 uint32_t *pChannels,
136 uint32_t *pLatencyMs,
137 uint32_t flags);
138
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800139 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
140 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700141
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800142 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700143
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800144 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700145
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800146 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700147
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800148 virtual audio_io_handle_t openInput(uint32_t *pDevices,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700149 uint32_t *pSamplingRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800150 audio_format_t *pFormat,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700151 uint32_t *pChannels,
Glenn Kastende9719b2012-01-27 12:32:34 -0800152 audio_in_acoustics_t acoustics);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700153
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800154 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700155
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800156 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700157
158 virtual status_t setVoiceVolume(float volume);
159
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800160 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
161 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700162
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800163 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const;
164
Mathias Agopian65ab4712010-07-14 17:59:35 -0700165 virtual int newAudioSessionId();
166
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700167 virtual void acquireAudioSessionId(int audioSession);
168
169 virtual void releaseAudioSessionId(int audioSession);
170
Glenn Kastenf587ba52012-01-26 16:25:10 -0800171 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700172
Glenn Kastenf587ba52012-01-26 16:25:10 -0800173 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700174
Glenn Kasten5e92a782012-01-30 07:40:52 -0800175 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800176 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700177
178 virtual sp<IEffect> createEffect(pid_t pid,
179 effect_descriptor_t *pDesc,
180 const sp<IEffectClient>& effectClient,
181 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800182 audio_io_handle_t io,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700183 int sessionId,
184 status_t *status,
185 int *id,
186 int *enabled);
187
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800188 virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
189 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700190
Mathias Agopian65ab4712010-07-14 17:59:35 -0700191 virtual status_t onTransact(
192 uint32_t code,
193 const Parcel& data,
194 Parcel* reply,
195 uint32_t flags);
196
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800197 // end of IAudioFlinger interface
198
199private:
Glenn Kastenf78aee72012-01-04 11:00:47 -0800200 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700201
Glenn Kastenc59c0042012-02-02 14:06:11 -0800202 bool btNrecIsOff() const { return mBtNrecIsOff; }
Eric Laurent59bd0da2011-08-01 09:52:20 -0700203
Mathias Agopian65ab4712010-07-14 17:59:35 -0700204 AudioFlinger();
205 virtual ~AudioFlinger();
206
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800207 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
208 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? NO_INIT : NO_ERROR; }
209
Glenn Kasten000f0e32012-03-01 17:10:56 -0800210 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700211 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800212
Dima Zavin799a70e2011-04-18 16:57:27 -0700213 audio_hw_device_t* findSuitableHwDev_l(uint32_t devices);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700214 void purgeStaleEffects_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700215
John Grossman4ff14ba2012-02-08 16:37:41 -0800216 static nsecs_t mStandbyTimeInNsecs;
217
Mathias Agopian65ab4712010-07-14 17:59:35 -0700218 // Internal dump utilites.
219 status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
220 status_t dumpClients(int fd, const Vector<String16>& args);
221 status_t dumpInternals(int fd, const Vector<String16>& args);
222
223 // --- Client ---
224 class Client : public RefBase {
225 public:
226 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
227 virtual ~Client();
Glenn Kasten435dbe62012-01-30 10:15:48 -0800228 sp<MemoryDealer> heap() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700229 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800230 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700231
John Grossman4ff14ba2012-02-08 16:37:41 -0800232 bool reserveTimedTrack();
233 void releaseTimedTrack();
234
Mathias Agopian65ab4712010-07-14 17:59:35 -0700235 private:
236 Client(const Client&);
237 Client& operator = (const Client&);
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800238 const sp<AudioFlinger> mAudioFlinger;
239 const sp<MemoryDealer> mMemoryDealer;
240 const pid_t mPid;
John Grossman4ff14ba2012-02-08 16:37:41 -0800241
242 Mutex mTimedTrackLock;
243 int mTimedTrackCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700244 };
245
246 // --- Notification Client ---
247 class NotificationClient : public IBinder::DeathRecipient {
248 public:
249 NotificationClient(const sp<AudioFlinger>& audioFlinger,
250 const sp<IAudioFlingerClient>& client,
251 pid_t pid);
252 virtual ~NotificationClient();
253
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800254 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700255
256 // IBinder::DeathRecipient
257 virtual void binderDied(const wp<IBinder>& who);
258
259 private:
260 NotificationClient(const NotificationClient&);
261 NotificationClient& operator = (const NotificationClient&);
262
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800263 const sp<AudioFlinger> mAudioFlinger;
264 const pid_t mPid;
265 const sp<IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700266 };
267
268 class TrackHandle;
269 class RecordHandle;
270 class RecordThread;
271 class PlaybackThread;
272 class MixerThread;
273 class DirectOutputThread;
274 class DuplicatingThread;
275 class Track;
276 class RecordTrack;
277 class EffectModule;
278 class EffectHandle;
279 class EffectChain;
Dima Zavin799a70e2011-04-18 16:57:27 -0700280 struct AudioStreamOut;
281 struct AudioStreamIn;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700282
283 class ThreadBase : public Thread {
284 public:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700285
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800286 enum type_t {
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700287 MIXER, // Thread class is MixerThread
288 DIRECT, // Thread class is DirectOutputThread
289 DUPLICATING, // Thread class is DuplicatingThread
290 RECORD // Thread class is RecordThread
291 };
292
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800293 ThreadBase (const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, uint32_t device, type_t type);
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800294 virtual ~ThreadBase();
295
Mathias Agopian65ab4712010-07-14 17:59:35 -0700296 status_t dumpBase(int fd, const Vector<String16>& args);
Eric Laurent1d2bff02011-07-24 17:49:51 -0700297 status_t dumpEffectChains(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700298
Eric Laurentfeb0db62011-07-22 09:04:31 -0700299 void clearPowerManager();
300
Mathias Agopian65ab4712010-07-14 17:59:35 -0700301 // base for record and playback
302 class TrackBase : public AudioBufferProvider, public RefBase {
303
304 public:
305 enum track_state {
306 IDLE,
307 TERMINATED,
Glenn Kasten99e53b82012-01-19 08:59:58 -0800308 // These are order-sensitive; do not change order without reviewing the impact.
309 // In particular there are assumptions about > STOPPED.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700310 STOPPED,
311 RESUMING,
312 ACTIVE,
313 PAUSING,
314 PAUSED
315 };
316
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800317 TrackBase(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700318 const sp<Client>& client,
319 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800320 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700321 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700322 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700323 const sp<IMemory>& sharedBuffer,
324 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800325 virtual ~TrackBase();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700326
Glenn Kasten6dbc1352012-02-02 10:56:47 -0800327 virtual status_t start(pid_t tid) = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700328 virtual void stop() = 0;
Glenn Kastenc59c0042012-02-02 14:06:11 -0800329 sp<IMemory> getCblk() const { return mCblkMemory; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700330 audio_track_cblk_t* cblk() const { return mCblk; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800331 int sessionId() const { return mSessionId; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700332
333 protected:
334 friend class ThreadBase;
335 friend class RecordHandle;
336 friend class PlaybackThread;
337 friend class RecordThread;
338 friend class MixerThread;
339 friend class DirectOutputThread;
340
341 TrackBase(const TrackBase&);
342 TrackBase& operator = (const TrackBase&);
343
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800344 // AudioBufferProvider interface
345 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700346 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
347
Glenn Kasten58f30212012-01-12 12:27:51 -0800348 audio_format_t format() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700349 return mFormat;
350 }
351
Glenn Kastenc59c0042012-02-02 14:06:11 -0800352 int channelCount() const { return mChannelCount; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700353
Glenn Kastenc59c0042012-02-02 14:06:11 -0800354 uint32_t channelMask() const { return mChannelMask; }
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700355
Glenn Kastenc59c0042012-02-02 14:06:11 -0800356 int sampleRate() const; // FIXME inline after cblk sr moved
Mathias Agopian65ab4712010-07-14 17:59:35 -0700357
358 void* getBuffer(uint32_t offset, uint32_t frames) const;
359
360 bool isStopped() const {
361 return mState == STOPPED;
362 }
363
364 bool isTerminated() const {
365 return mState == TERMINATED;
366 }
367
368 bool step();
369 void reset();
370
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800371 const wp<ThreadBase> mThread;
372 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700373 sp<IMemory> mCblkMemory;
374 audio_track_cblk_t* mCblk;
375 void* mBuffer;
376 void* mBufferEnd;
377 uint32_t mFrameCount;
378 // we don't really need a lock for these
Glenn Kastenb853e982012-01-26 13:39:18 -0800379 track_state mState;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800380 const audio_format_t mFormat;
Glenn Kasten5cf034d2012-02-21 10:35:56 -0800381 bool mStepServerFailed;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800382 const int mSessionId;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700383 uint8_t mChannelCount;
384 uint32_t mChannelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700385 };
386
387 class ConfigEvent {
388 public:
389 ConfigEvent() : mEvent(0), mParam(0) {}
390
391 int mEvent;
392 int mParam;
393 };
394
Eric Laurentfeb0db62011-07-22 09:04:31 -0700395 class PMDeathRecipient : public IBinder::DeathRecipient {
396 public:
397 PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
398 virtual ~PMDeathRecipient() {}
399
400 // IBinder::DeathRecipient
401 virtual void binderDied(const wp<IBinder>& who);
402
403 private:
404 PMDeathRecipient(const PMDeathRecipient&);
405 PMDeathRecipient& operator = (const PMDeathRecipient&);
406
407 wp<ThreadBase> mThread;
408 };
409
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700410 virtual status_t initCheck() const = 0;
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800411 type_t type() const { return mType; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800412 uint32_t sampleRate() const { return mSampleRate; }
413 int channelCount() const { return mChannelCount; }
414 audio_format_t format() const { return mFormat; }
415 size_t frameCount() const { return mFrameCount; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700416 void wakeUp() { mWaitWorkCV.broadcast(); }
Glenn Kastenb28686f2012-01-06 08:39:38 -0800417 // Should be "virtual status_t requestExitAndWait()" and override same
418 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700419 void exit();
420 virtual bool checkForNewParameters_l() = 0;
421 virtual status_t setParameters(const String8& keyValuePairs);
422 virtual String8 getParameters(const String8& keys) = 0;
423 virtual void audioConfigChanged_l(int event, int param = 0) = 0;
424 void sendConfigEvent(int event, int param = 0);
425 void sendConfigEvent_l(int event, int param = 0);
426 void processConfigEvents();
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800427 audio_io_handle_t id() const { return mId;}
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800428 bool standby() const { return mStandby; }
429 uint32_t device() const { return mDevice; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700430 virtual audio_stream_t* stream() = 0;
431
432 sp<EffectHandle> createEffect_l(
433 const sp<AudioFlinger::Client>& client,
434 const sp<IEffectClient>& effectClient,
435 int32_t priority,
436 int sessionId,
437 effect_descriptor_t *desc,
438 int *enabled,
439 status_t *status);
440 void disconnectEffect(const sp< EffectModule>& effect,
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700441 const wp<EffectHandle>& handle,
Glenn Kasten58123c32012-02-03 10:32:24 -0800442 bool unpinIfLast);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700443
444 // return values for hasAudioSession (bit field)
445 enum effect_state {
446 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
447 // effect
448 TRACK_SESSION = 0x2 // the audio session corresponds to at least one
449 // track
450 };
451
452 // get effect chain corresponding to session Id.
453 sp<EffectChain> getEffectChain(int sessionId);
454 // same as getEffectChain() but must be called with ThreadBase mutex locked
455 sp<EffectChain> getEffectChain_l(int sessionId);
456 // add an effect chain to the chain list (mEffectChains)
457 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
458 // remove an effect chain from the chain list (mEffectChains)
459 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
Glenn Kastend805b712012-02-24 15:42:48 -0800460 // lock all effect chains Mutexes. Must be called before releasing the
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700461 // ThreadBase mutex before processing the mixer and effects. This guarantees the
462 // integrity of the chains during the process.
Glenn Kastend805b712012-02-24 15:42:48 -0800463 // Also sets the parameter 'effectChains' to current value of mEffectChains.
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700464 void lockEffectChains_l(Vector<sp <EffectChain> >& effectChains);
465 // unlock effect chains after process
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800466 void unlockEffectChains(const Vector<sp<EffectChain> >& effectChains);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700467 // set audio mode to all effect chains
Glenn Kastenf78aee72012-01-04 11:00:47 -0800468 void setMode(audio_mode_t mode);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700469 // get effect module with corresponding ID on specified audio session
470 sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId);
471 // add and effect module. Also creates the effect chain is none exists for
472 // the effects audio session
473 status_t addEffect_l(const sp< EffectModule>& effect);
474 // remove and effect module. Also removes the effect chain is this was the last
475 // effect
476 void removeEffect_l(const sp< EffectModule>& effect);
477 // detach all tracks connected to an auxiliary effect
478 virtual void detachAuxEffect_l(int effectId) {}
479 // returns either EFFECT_SESSION if effects on this audio session exist in one
480 // chain, or TRACK_SESSION if tracks on this audio session exist, or both
481 virtual uint32_t hasAudioSession(int sessionId) = 0;
482 // the value returned by default implementation is not important as the
483 // strategy is only meaningful for PlaybackThread which implements this method
484 virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700485
Eric Laurent59255e42011-07-27 19:49:51 -0700486 // suspend or restore effect according to the type of effect passed. a NULL
487 // type pointer means suspend all effects in the session
488 void setEffectSuspended(const effect_uuid_t *type,
489 bool suspend,
490 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
491 // check if some effects must be suspended/restored when an effect is enabled
492 // or disabled
Eric Laurenta85a74a2011-10-19 11:44:54 -0700493 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
Eric Laurent59255e42011-07-27 19:49:51 -0700494 bool enabled,
495 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
Eric Laurenta85a74a2011-10-19 11:44:54 -0700496 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
497 bool enabled,
498 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700499 mutable Mutex mLock;
500
501 protected:
502
Eric Laurent59255e42011-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 Laurentfeb0db62011-07-22 09:04:31 -0700512 void acquireWakeLock();
513 void acquireWakeLock_l();
514 void releaseWakeLock();
515 void releaseWakeLock_l();
Eric Laurent59255e42011-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 Laurentfeb0db62011-07-22 09:04:31 -0700525
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700526 friend class AudioFlinger;
Mathias Agopian65ab4712010-07-14 17:59:35 -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
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800536 const type_t mType;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700537 Condition mWaitWorkCV;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800538 const sp<AudioFlinger> mAudioFlinger;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700539 uint32_t mSampleRate;
540 size_t mFrameCount;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700541 uint32_t mChannelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700542 uint16_t mChannelCount;
Glenn Kastenb9980652012-01-11 09:48:27 -0800543 size_t mFrameSize;
Glenn Kasten58f30212012-01-12 12:27:51 -0800544 audio_format_t mFormat;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700545 Condition mParamCond;
546 Vector<String8> mNewParameters;
547 status_t mParamStatus;
Glenn Kastenf3990f22011-12-13 11:50:00 -0800548 Vector<ConfigEvent> mConfigEvents;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700549 bool mStandby;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800550 const audio_io_handle_t mId;
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700551 Vector< sp<EffectChain> > mEffectChains;
552 uint32_t mDevice; // output device for PlaybackThread
553 // input + output devices for RecordThread
Glenn Kasten480b4682012-02-28 12:30:08 -0800554 static const int kNameLength = 16; // prctl(PR_SET_NAME) limit
Eric Laurentfeb0db62011-07-22 09:04:31 -0700555 char mName[kNameLength];
556 sp<IPowerManager> mPowerManager;
557 sp<IBinder> mWakeLockToken;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800558 const sp<PMDeathRecipient> mDeathRecipient;
Eric Laurent59255e42011-07-27 19:49:51 -0700559 // list of suspended effects per session and per type. The first vector is
560 // keyed by session ID, the second by type UUID timeLow field
561 KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700562 };
563
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800564 struct stream_type_t {
565 stream_type_t()
566 : volume(1.0f),
567 mute(false),
568 valid(true)
569 {
570 }
571 float volume;
572 bool mute;
573 bool valid;
574 };
575
Mathias Agopian65ab4712010-07-14 17:59:35 -0700576 // --- PlaybackThread ---
577 class PlaybackThread : public ThreadBase {
578 public:
579
Mathias Agopian65ab4712010-07-14 17:59:35 -0700580 enum mixer_state {
Glenn Kastend805b712012-02-24 15:42:48 -0800581 MIXER_IDLE, // no active tracks
582 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
583 MIXER_TRACKS_READY // at least one active track, and at least one track has data
584 // standby mode does not have an enum value
585 // suspend by audio policy manager is orthogonal to mixer state
Glenn Kasten000f0e32012-03-01 17:10:56 -0800586#if 1
587 // FIXME remove these hacks for threadLoop_prepareTracks_l
588 , MIXER_CONTINUE // "continue;"
589#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -0700590 };
591
592 // playback track
593 class Track : public TrackBase {
594 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800595 Track( PlaybackThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700596 const sp<Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800597 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700598 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800599 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700600 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700601 int frameCount,
602 const sp<IMemory>& sharedBuffer,
603 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800604 virtual ~Track();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700605
606 void dump(char* buffer, size_t size);
Glenn Kasten6dbc1352012-02-02 10:56:47 -0800607 virtual status_t start(pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700608 virtual void stop();
609 void pause();
610
611 void flush();
612 void destroy();
613 void mute(bool);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700614 int name() const {
615 return mName;
616 }
617
Glenn Kasten02bbd202012-02-08 12:35:35 -0800618 audio_stream_type_t streamType() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700619 return mStreamType;
620 }
621 status_t attachAuxEffect(int EffectId);
622 void setAuxBuffer(int EffectId, int32_t *buffer);
Glenn Kastenc59c0042012-02-02 14:06:11 -0800623 int32_t *auxBuffer() const { return mAuxBuffer; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700624 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800625 int16_t *mainBuffer() const { return mMainBuffer; }
626 int auxEffectId() const { return mAuxEffectId; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700627
Mathias Agopian65ab4712010-07-14 17:59:35 -0700628 protected:
629 friend class ThreadBase;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700630 friend class TrackHandle;
631 friend class PlaybackThread;
632 friend class MixerThread;
633 friend class DirectOutputThread;
634
635 Track(const Track&);
636 Track& operator = (const Track&);
637
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800638 // AudioBufferProvider interface
639 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS);
640 // releaseBuffer() not overridden
641
John Grossman4ff14ba2012-02-08 16:37:41 -0800642 virtual uint32_t framesReady() const;
643
Glenn Kastenc59c0042012-02-02 14:06:11 -0800644 bool isMuted() const { return mMute; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700645 bool isPausing() const {
646 return mState == PAUSING;
647 }
648 bool isPaused() const {
649 return mState == PAUSED;
650 }
651 bool isReady() const;
652 void setPaused() { mState = PAUSED; }
653 void reset();
654
655 bool isOutputTrack() const {
Dima Zavinfce7a472011-04-19 22:30:36 -0700656 return (mStreamType == AUDIO_STREAM_CNT);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700657 }
658
John Grossman4ff14ba2012-02-08 16:37:41 -0800659 virtual bool isTimedTrack() const { return false; }
660
Mathias Agopian65ab4712010-07-14 17:59:35 -0700661 // we don't really need a lock for these
Mathias Agopian65ab4712010-07-14 17:59:35 -0700662 volatile bool mMute;
663 // FILLED state is used for suppressing volume ramp at begin of playing
664 enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
665 mutable uint8_t mFillingUpStatus;
666 int8_t mRetryCount;
667 sp<IMemory> mSharedBuffer;
668 bool mResetDone;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800669 audio_stream_type_t mStreamType;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700670 int mName;
671 int16_t *mMainBuffer;
672 int32_t *mAuxBuffer;
673 int mAuxEffectId;
Eric Laurent8f45bd72010-08-31 13:50:07 -0700674 bool mHasVolumeController;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700675 }; // end of Track
676
John Grossman4ff14ba2012-02-08 16:37:41 -0800677 class TimedTrack : public Track {
678 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800679 static sp<TimedTrack> create(PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -0800680 const sp<Client>& client,
681 audio_stream_type_t streamType,
682 uint32_t sampleRate,
683 audio_format_t format,
684 uint32_t channelMask,
685 int frameCount,
686 const sp<IMemory>& sharedBuffer,
687 int sessionId);
688 ~TimedTrack();
689
690 class TimedBuffer {
691 public:
692 TimedBuffer();
693 TimedBuffer(const sp<IMemory>& buffer, int64_t pts);
694 const sp<IMemory>& buffer() const { return mBuffer; }
695 int64_t pts() const { return mPTS; }
696 int position() const { return mPosition; }
697 void setPosition(int pos) { mPosition = pos; }
698 private:
699 sp<IMemory> mBuffer;
700 int64_t mPTS;
701 int mPosition;
702 };
703
704 virtual bool isTimedTrack() const { return true; }
705
706 virtual uint32_t framesReady() const;
707
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800708 // AudioBufferProvider interface
709 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts);
John Grossman4ff14ba2012-02-08 16:37:41 -0800710 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800711
John Grossman4ff14ba2012-02-08 16:37:41 -0800712 void timedYieldSamples(AudioBufferProvider::Buffer* buffer);
713 void timedYieldSilence(uint32_t numFrames,
714 AudioBufferProvider::Buffer* buffer);
715
716 status_t allocateTimedBuffer(size_t size,
717 sp<IMemory>* buffer);
718 status_t queueTimedBuffer(const sp<IMemory>& buffer,
719 int64_t pts);
720 status_t setMediaTimeTransform(const LinearTransform& xform,
721 TimedAudioTrack::TargetTimeline target);
722 void trimTimedBufferQueue_l();
723
724 private:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800725 TimedTrack(PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -0800726 const sp<Client>& client,
727 audio_stream_type_t streamType,
728 uint32_t sampleRate,
729 audio_format_t format,
730 uint32_t channelMask,
731 int frameCount,
732 const sp<IMemory>& sharedBuffer,
733 int sessionId);
734
735 uint64_t mLocalTimeFreq;
736 LinearTransform mLocalTimeToSampleTransform;
737 sp<MemoryDealer> mTimedMemoryDealer;
738 Vector<TimedBuffer> mTimedBufferQueue;
739 uint8_t* mTimedSilenceBuffer;
740 uint32_t mTimedSilenceBufferSize;
741 mutable Mutex mTimedBufferQueueLock;
742 bool mTimedAudioOutputOnTime;
743 CCHelper mCCHelper;
744
745 Mutex mMediaTimeTransformLock;
746 LinearTransform mMediaTimeTransform;
747 bool mMediaTimeTransformValid;
748 TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget;
749 };
750
Mathias Agopian65ab4712010-07-14 17:59:35 -0700751
752 // playback track
753 class OutputTrack : public Track {
754 public:
755
756 class Buffer: public AudioBufferProvider::Buffer {
757 public:
758 int16_t *mBuffer;
759 };
760
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800761 OutputTrack(PlaybackThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700762 DuplicatingThread *sourceThread,
763 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800764 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700765 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700766 int frameCount);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800767 virtual ~OutputTrack();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700768
Glenn Kasten6dbc1352012-02-02 10:56:47 -0800769 virtual status_t start(pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700770 virtual void stop();
771 bool write(int16_t* data, uint32_t frames);
Glenn Kastena1117922012-01-26 10:53:32 -0800772 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800773 bool isActive() const { return mActive; }
774 const wp<ThreadBase>& thread() const { return mThread; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700775
776 private:
777
Glenn Kasten335787f2012-01-20 17:00:00 -0800778 enum {
779 NO_MORE_BUFFERS = 0x80000001, // same in AudioTrack.h, ok to be different value
780 };
781
Mathias Agopian65ab4712010-07-14 17:59:35 -0700782 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs);
783 void clearBufferQueue();
784
785 // Maximum number of pending buffers allocated by OutputTrack::write()
786 static const uint8_t kMaxOverFlowBuffers = 10;
787
788 Vector < Buffer* > mBufferQueue;
789 AudioBufferProvider::Buffer mOutBuffer;
790 bool mActive;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800791 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700792 }; // end of OutputTrack
793
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800794 PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
795 audio_io_handle_t id, uint32_t device, type_t type);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700796 virtual ~PlaybackThread();
797
798 virtual status_t dump(int fd, const Vector<String16>& args);
799
800 // Thread virtuals
801 virtual status_t readyToRun();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800802 virtual bool threadLoop();
803
804 // RefBase
Mathias Agopian65ab4712010-07-14 17:59:35 -0700805 virtual void onFirstRef();
806
Glenn Kasten000f0e32012-03-01 17:10:56 -0800807protected:
808 // Code snippets that were lifted up out of threadLoop()
809 virtual void threadLoop_mix() = 0;
810 virtual void threadLoop_sleepTime() = 0;
811 virtual void threadLoop_write();
812 virtual void threadLoop_standby();
813
814 // Non-trivial for DUPLICATING only
Glenn Kasten438b0362012-03-06 11:24:48 -0800815 virtual void updateWaitTime_l() { }
Glenn Kasten000f0e32012-03-01 17:10:56 -0800816
817 // Non-trivial for DIRECT only
818 virtual void applyVolume() { }
819
820 // FIXME merge these
821 // Non-trivial for MIXER and DUPLICATING only
822 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) { return MIXER_IDLE; }
823 // Non-trivial for DIRECT only
824 virtual mixer_state threadLoop_prepareTracks_l(sp<Track>& trackToRemove)
825 { return MIXER_IDLE; }
826
827public:
828
Glenn Kastene0feee32011-12-13 11:53:26 -0800829 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700830
Mathias Agopian65ab4712010-07-14 17:59:35 -0700831 virtual uint32_t latency() const;
832
Glenn Kasten6637baa2012-01-09 09:40:36 -0800833 void setMasterVolume(float value);
834 void setMasterMute(bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700835
Glenn Kasten6637baa2012-01-09 09:40:36 -0800836 void setStreamVolume(audio_stream_type_t stream, float value);
837 void setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700838
Glenn Kasten6637baa2012-01-09 09:40:36 -0800839 float streamVolume(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700840
Mathias Agopian65ab4712010-07-14 17:59:35 -0700841 sp<Track> createTrack_l(
842 const sp<AudioFlinger::Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800843 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700844 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800845 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700846 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700847 int frameCount,
848 const sp<IMemory>& sharedBuffer,
849 int sessionId,
John Grossman4ff14ba2012-02-08 16:37:41 -0800850 bool isTimed,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700851 status_t *status);
852
Glenn Kastenaed850d2012-01-26 09:46:34 -0800853 AudioStreamOut* getOutput() const;
Eric Laurentb8ba0a92011-08-07 16:32:26 -0700854 AudioStreamOut* clearOutput();
855 virtual audio_stream_t* stream();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700856
Mathias Agopian65ab4712010-07-14 17:59:35 -0700857 void suspend() { mSuspended++; }
Glenn Kastenc455fe92012-02-29 07:07:30 -0800858 void restore() { if (mSuspended > 0) mSuspended--; }
859 bool isSuspended() const { return (mSuspended > 0); }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700860 virtual String8 getParameters(const String8& keys);
861 virtual void audioConfigChanged_l(int event, int param = 0);
862 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Glenn Kastenc59c0042012-02-02 14:06:11 -0800863 int16_t *mixBuffer() const { return mMixBuffer; };
Mathias Agopian65ab4712010-07-14 17:59:35 -0700864
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700865 virtual void detachAuxEffect_l(int effectId);
Eric Laurentde070132010-07-13 04:45:46 -0700866 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track,
867 int EffectId);
868 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track,
869 int EffectId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700870
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700871 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
872 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
873 virtual uint32_t hasAudioSession(int sessionId);
874 virtual uint32_t getStrategyForSession_l(int sessionId);
Eric Laurentde070132010-07-13 04:45:46 -0700875
Glenn Kastenfff6d712012-01-12 16:38:12 -0800876 void setStreamValid(audio_stream_type_t streamType, bool valid);
Eric Laurent9f6530f2011-08-30 10:18:54 -0700877
Mathias Agopian65ab4712010-07-14 17:59:35 -0700878 protected:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700879 int16_t* mMixBuffer;
Glenn Kastenc455fe92012-02-29 07:07:30 -0800880 uint32_t mSuspended; // suspend count, > 0 means suspended
Mathias Agopian65ab4712010-07-14 17:59:35 -0700881 int mBytesWritten;
Glenn Kasten98067102011-12-13 11:47:54 -0800882 private:
Glenn Kasten99e53b82012-01-19 08:59:58 -0800883 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
884 // PlaybackThread needs to find out if master-muted, it checks it's local
885 // copy rather than the one in AudioFlinger. This optimization saves a lock.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700886 bool mMasterMute;
Glenn Kasten6637baa2012-01-09 09:40:36 -0800887 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Glenn Kasten98067102011-12-13 11:47:54 -0800888 protected:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700889 SortedVector< wp<Track> > mActiveTracks;
890
891 virtual int getTrackName_l() = 0;
892 virtual void deleteTrackName_l(int name) = 0;
Eric Laurent162b40b2011-12-05 09:47:19 -0800893 virtual uint32_t activeSleepTimeUs();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700894 virtual uint32_t idleSleepTimeUs() = 0;
Eric Laurent25cbe0e2010-08-18 18:13:17 -0700895 virtual uint32_t suspendSleepTimeUs() = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700896
Glenn Kasten37d825e2012-02-24 07:21:48 -0800897 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
898 void checkSilentMode_l();
899
Mathias Agopian65ab4712010-07-14 17:59:35 -0700900 private:
901
902 friend class AudioFlinger;
903 friend class OutputTrack;
904 friend class Track;
905 friend class TrackBase;
906 friend class MixerThread;
907 friend class DirectOutputThread;
908 friend class DuplicatingThread;
909
910 PlaybackThread(const Client&);
911 PlaybackThread& operator = (const PlaybackThread&);
912
913 status_t addTrack_l(const sp<Track>& track);
914 void destroyTrack_l(const sp<Track>& track);
Eric Laurentb469b942011-05-09 12:09:06 -0700915 void removeTrack_l(const sp<Track>& track);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700916
917 void readOutputParameters();
918
Mathias Agopian65ab4712010-07-14 17:59:35 -0700919 virtual status_t dumpInternals(int fd, const Vector<String16>& args);
920 status_t dumpTracks(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700921
922 SortedVector< sp<Track> > mTracks;
Glenn Kasten263709e2012-01-06 08:40:01 -0800923 // mStreamTypes[] uses 1 additional stream type internally for the OutputTrack used by DuplicatingThread
Dima Zavinfce7a472011-04-19 22:30:36 -0700924 stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1];
Glenn Kastenaed850d2012-01-26 09:46:34 -0800925 AudioStreamOut *mOutput;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700926 float mMasterVolume;
927 nsecs_t mLastWriteTime;
928 int mNumWrites;
929 int mNumDelayedWrites;
930 bool mInWrite;
Glenn Kasten000f0e32012-03-01 17:10:56 -0800931
932 // FIXME rename these former local variables of threadLoop to standard "m" names
933 nsecs_t standbyTime;
934 size_t mixBufferSize;
935 uint32_t activeSleepTime;
936 uint32_t idleSleepTime;
937 uint32_t sleepTime;
938 // mixerStatus was local to the while !exitingPending loop
939 mixer_state mixerStatus;
940
941 // FIXME move these declarations into the specific sub-class that needs them
942 // MIXER only
943 bool longStandbyExit;
944 uint32_t sleepTimeShift;
945 // MIXER and DUPLICATING only
946 mixer_state mPrevMixerStatus; // previous status returned by prepareTracks_l()
947 // DIRECT only
948 nsecs_t standbyDelay;
949 // activeTrack was local to the while !exitingPending loop
950 sp<Track> activeTrack;
951 // DUPLICATING only
952 SortedVector < sp<OutputTrack> > outputTracks;
953 uint32_t writeFrames;
954 SortedVector < sp<OutputTrack> > mOutputTracks;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700955 };
956
957 class MixerThread : public PlaybackThread {
958 public:
Eric Laurentde070132010-07-13 04:45:46 -0700959 MixerThread (const sp<AudioFlinger>& audioFlinger,
Dima Zavin799a70e2011-04-18 16:57:27 -0700960 AudioStreamOut* output,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800961 audio_io_handle_t id,
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800962 uint32_t device,
963 type_t type = MIXER);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700964 virtual ~MixerThread();
965
966 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -0700967
Glenn Kastenfff6d712012-01-12 16:38:12 -0800968 void invalidateTracks(audio_stream_type_t streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700969 virtual bool checkForNewParameters_l();
970 virtual status_t dumpInternals(int fd, const Vector<String16>& args);
971
972 protected:
Glenn Kasten3e074702012-02-28 18:40:35 -0800973 // prepareTracks_l reads and writes mActiveTracks, and also returns the
974 // pending set of tracks to remove via Vector 'tracksToRemove'. The caller is
975 // responsible for clearing or destroying this Vector later on, when it
976 // is safe to do so. That will drop the final ref count and destroy the tracks.
Glenn Kasten000f0e32012-03-01 17:10:56 -0800977 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700978 virtual int getTrackName_l();
979 virtual void deleteTrackName_l(int name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700980 virtual uint32_t idleSleepTimeUs();
Eric Laurent25cbe0e2010-08-18 18:13:17 -0700981 virtual uint32_t suspendSleepTimeUs();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700982
Glenn Kasten000f0e32012-03-01 17:10:56 -0800983 // threadLoop snippets
984 virtual void threadLoop_mix();
985 virtual void threadLoop_sleepTime();
986
Eric Laurent27741442012-01-17 19:20:12 -0800987 AudioMixer* mAudioMixer;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700988 };
989
990 class DirectOutputThread : public PlaybackThread {
991 public:
992
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800993 DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
994 audio_io_handle_t id, uint32_t device);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800995 virtual ~DirectOutputThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700996
997 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -0700998
999 virtual bool checkForNewParameters_l();
1000
1001 protected:
1002 virtual int getTrackName_l();
1003 virtual void deleteTrackName_l(int name);
1004 virtual uint32_t activeSleepTimeUs();
1005 virtual uint32_t idleSleepTimeUs();
Eric Laurent25cbe0e2010-08-18 18:13:17 -07001006 virtual uint32_t suspendSleepTimeUs();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001007
Glenn Kasten000f0e32012-03-01 17:10:56 -08001008 // threadLoop snippets
1009 virtual mixer_state threadLoop_prepareTracks_l(sp<Track>& trackToRemove);
1010 virtual void threadLoop_mix();
1011 virtual void threadLoop_sleepTime();
1012 virtual void applyVolume();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001013
Glenn Kasten99e53b82012-01-19 08:59:58 -08001014 // volumes last sent to audio HAL with stream->set_volume()
1015 // FIXME use standard representation and names
Mathias Agopian65ab4712010-07-14 17:59:35 -07001016 float mLeftVolFloat;
1017 float mRightVolFloat;
1018 uint16_t mLeftVolShort;
1019 uint16_t mRightVolShort;
Glenn Kasten000f0e32012-03-01 17:10:56 -08001020
1021 // FIXME rename these former local variables of threadLoop to standard names
1022 // next 3 were local to the while !exitingPending loop
1023 bool rampVolume;
1024 uint16_t leftVol;
1025 uint16_t rightVol;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001026 };
1027
1028 class DuplicatingThread : public MixerThread {
1029 public:
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001030 DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
1031 audio_io_handle_t id);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001032 virtual ~DuplicatingThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001033
1034 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -07001035 void addOutputTrack(MixerThread* thread);
1036 void removeOutputTrack(MixerThread* thread);
1037 uint32_t waitTimeMs() { return mWaitTimeMs; }
1038 protected:
1039 virtual uint32_t activeSleepTimeUs();
1040
1041 private:
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08001042 bool outputsReady(const SortedVector<sp<OutputTrack> > &outputTracks);
Glenn Kasten000f0e32012-03-01 17:10:56 -08001043 protected:
1044 // threadLoop snippets
1045 virtual void threadLoop_mix();
1046 virtual void threadLoop_sleepTime();
1047 virtual void threadLoop_write();
1048 virtual void threadLoop_standby();
Glenn Kasten438b0362012-03-06 11:24:48 -08001049
1050 // called from threadLoop, addOutputTrack, removeOutputTrack
1051 virtual void updateWaitTime_l();
Glenn Kasten000f0e32012-03-01 17:10:56 -08001052 private:
Mathias Agopian65ab4712010-07-14 17:59:35 -07001053
Mathias Agopian65ab4712010-07-14 17:59:35 -07001054 uint32_t mWaitTimeMs;
1055 };
1056
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001057 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
1058 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
1059 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Glenn Kasten6637baa2012-01-09 09:40:36 -08001060 // no range check, AudioFlinger::mLock held
1061 bool streamMute_l(audio_stream_type_t stream) const
1062 { return mStreamTypes[stream].mute; }
1063 // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
1064 float streamVolume_l(audio_stream_type_t stream) const
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001065 { return mStreamTypes[stream].volume; }
Glenn Kastenb81cc8c2012-03-01 09:14:51 -08001066 void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001067
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001068 // allocate an audio_io_handle_t, session ID, or effect ID
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001069 uint32_t nextUniqueId();
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001070
Eric Laurent59255e42011-07-27 19:49:51 -07001071 status_t moveEffectChain_l(int sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -08001072 PlaybackThread *srcThread,
1073 PlaybackThread *dstThread,
Eric Laurent39e94f82010-07-28 01:32:47 -07001074 bool reRegister);
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08001075 // return thread associated with primary hardware device, or NULL
1076 PlaybackThread *primaryPlaybackThread_l() const;
1077 uint32_t primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001078
1079 friend class AudioBuffer;
1080
Glenn Kasten99e53b82012-01-19 08:59:58 -08001081 // server side of the client's IAudioTrack
Mathias Agopian65ab4712010-07-14 17:59:35 -07001082 class TrackHandle : public android::BnAudioTrack {
1083 public:
1084 TrackHandle(const sp<PlaybackThread::Track>& track);
1085 virtual ~TrackHandle();
Glenn Kasten90716c52012-01-26 13:40:12 -08001086 virtual sp<IMemory> getCblk() const;
Glenn Kasten6dbc1352012-02-02 10:56:47 -08001087 virtual status_t start(pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001088 virtual void stop();
1089 virtual void flush();
1090 virtual void mute(bool);
1091 virtual void pause();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001092 virtual status_t attachAuxEffect(int effectId);
John Grossman4ff14ba2012-02-08 16:37:41 -08001093 virtual status_t allocateTimedBuffer(size_t size,
1094 sp<IMemory>* buffer);
1095 virtual status_t queueTimedBuffer(const sp<IMemory>& buffer,
1096 int64_t pts);
1097 virtual status_t setMediaTimeTransform(const LinearTransform& xform,
1098 int target);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001099 virtual status_t onTransact(
1100 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
1101 private:
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001102 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001103 };
1104
1105 friend class Client;
1106 friend class PlaybackThread::Track;
1107
1108
1109 void removeClient_l(pid_t pid);
1110 void removeNotificationClient(pid_t pid);
1111
1112
1113 // record thread
1114 class RecordThread : public ThreadBase, public AudioBufferProvider
1115 {
1116 public:
1117
1118 // record track
1119 class RecordTrack : public TrackBase {
1120 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001121 RecordTrack(RecordThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001122 const sp<Client>& client,
1123 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001124 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001125 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001126 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001127 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001128 virtual ~RecordTrack();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001129
Glenn Kasten6dbc1352012-02-02 10:56:47 -08001130 virtual status_t start(pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001131 virtual void stop();
1132
1133 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
1134 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
1135
1136 void dump(char* buffer, size_t size);
Eric Laurent59255e42011-07-27 19:49:51 -07001137
Mathias Agopian65ab4712010-07-14 17:59:35 -07001138 private:
1139 friend class AudioFlinger;
1140 friend class RecordThread;
1141
1142 RecordTrack(const RecordTrack&);
1143 RecordTrack& operator = (const RecordTrack&);
1144
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001145 // AudioBufferProvider interface
1146 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS);
1147 // releaseBuffer() not overridden
Mathias Agopian65ab4712010-07-14 17:59:35 -07001148
1149 bool mOverflow;
1150 };
1151
1152
1153 RecordThread(const sp<AudioFlinger>& audioFlinger,
Dima Zavin799a70e2011-04-18 16:57:27 -07001154 AudioStreamIn *input,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001155 uint32_t sampleRate,
1156 uint32_t channels,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001157 audio_io_handle_t id,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001158 uint32_t device);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001159 virtual ~RecordThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001160
Glenn Kasten000f0e32012-03-01 17:10:56 -08001161 // Thread
Mathias Agopian65ab4712010-07-14 17:59:35 -07001162 virtual bool threadLoop();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001163 virtual status_t readyToRun();
Glenn Kasten000f0e32012-03-01 17:10:56 -08001164
1165 // RefBase
Mathias Agopian65ab4712010-07-14 17:59:35 -07001166 virtual void onFirstRef();
1167
Glenn Kastene0feee32011-12-13 11:53:26 -08001168 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001169 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1170 const sp<AudioFlinger::Client>& client,
1171 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001172 audio_format_t format,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001173 int channelMask,
1174 int frameCount,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001175 int sessionId,
1176 status_t *status);
1177
Mathias Agopian65ab4712010-07-14 17:59:35 -07001178 status_t start(RecordTrack* recordTrack);
Glenn Kasten6dbc1352012-02-02 10:56:47 -08001179 status_t start(RecordTrack* recordTrack, pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001180 void stop(RecordTrack* recordTrack);
1181 status_t dump(int fd, const Vector<String16>& args);
Glenn Kastenaed850d2012-01-26 09:46:34 -08001182 AudioStreamIn* getInput() const;
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001183 AudioStreamIn* clearInput();
1184 virtual audio_stream_t* stream();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001185
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001186 // AudioBufferProvider interface
1187 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001188 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001189
Mathias Agopian65ab4712010-07-14 17:59:35 -07001190 virtual bool checkForNewParameters_l();
1191 virtual String8 getParameters(const String8& keys);
1192 virtual void audioConfigChanged_l(int event, int param = 0);
1193 void readInputParameters();
1194 virtual unsigned int getInputFramesLost();
1195
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001196 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1197 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
1198 virtual uint32_t hasAudioSession(int sessionId);
Eric Laurent59bd0da2011-08-01 09:52:20 -07001199 RecordTrack* track();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001200
Mathias Agopian65ab4712010-07-14 17:59:35 -07001201 private:
1202 RecordThread();
Dima Zavin799a70e2011-04-18 16:57:27 -07001203 AudioStreamIn *mInput;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001204 RecordTrack* mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001205 sp<RecordTrack> mActiveTrack;
1206 Condition mStartStopCond;
1207 AudioResampler *mResampler;
1208 int32_t *mRsmpOutBuffer;
1209 int16_t *mRsmpInBuffer;
1210 size_t mRsmpInIndex;
1211 size_t mInputBytes;
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001212 const int mReqChannelCount;
1213 const uint32_t mReqSampleRate;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001214 ssize_t mBytesRead;
1215 };
1216
Glenn Kasten99e53b82012-01-19 08:59:58 -08001217 // server side of the client's IAudioRecord
Mathias Agopian65ab4712010-07-14 17:59:35 -07001218 class RecordHandle : public android::BnAudioRecord {
1219 public:
1220 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
1221 virtual ~RecordHandle();
Glenn Kasten90716c52012-01-26 13:40:12 -08001222 virtual sp<IMemory> getCblk() const;
Glenn Kasten6dbc1352012-02-02 10:56:47 -08001223 virtual status_t start(pid_t tid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001224 virtual void stop();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001225 virtual status_t onTransact(
1226 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
1227 private:
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001228 const sp<RecordThread::RecordTrack> mRecordTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001229 };
1230
1231 //--- Audio Effect Management
1232
1233 // EffectModule and EffectChain classes both have their own mutex to protect
1234 // state changes or resource modifications. Always respect the following order
1235 // if multiple mutexes must be acquired to avoid cross deadlock:
1236 // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule
1237
1238 // The EffectModule class is a wrapper object controlling the effect engine implementation
1239 // in the effect library. It prevents concurrent calls to process() and command() functions
1240 // from different client threads. It keeps a list of EffectHandle objects corresponding
1241 // to all client applications using this effect and notifies applications of effect state,
1242 // control or parameter changes. It manages the activation state machine to send appropriate
1243 // reset, enable, disable commands to effect engine and provide volume
1244 // ramping when effects are activated/deactivated.
1245 // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by
1246 // the attached track(s) to accumulate their auxiliary channel.
1247 class EffectModule: public RefBase {
1248 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001249 EffectModule(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001250 const wp<AudioFlinger::EffectChain>& chain,
1251 effect_descriptor_t *desc,
1252 int id,
1253 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001254 virtual ~EffectModule();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001255
1256 enum effect_state {
1257 IDLE,
1258 RESTART,
1259 STARTING,
1260 ACTIVE,
1261 STOPPING,
Eric Laurentec437d82011-07-26 20:54:46 -07001262 STOPPED,
1263 DESTROYED
Mathias Agopian65ab4712010-07-14 17:59:35 -07001264 };
1265
Glenn Kastenc59c0042012-02-02 14:06:11 -08001266 int id() const { return mId; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001267 void process();
1268 void updateState();
Eric Laurent25f43952010-07-28 05:40:18 -07001269 status_t command(uint32_t cmdCode,
1270 uint32_t cmdSize,
1271 void *pCmdData,
1272 uint32_t *replySize,
1273 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001274
1275 void reset_l();
1276 status_t configure();
1277 status_t init();
Glenn Kasten28243dd2012-01-26 13:43:46 -08001278 effect_state state() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001279 return mState;
1280 }
1281 uint32_t status() {
1282 return mStatus;
1283 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001284 int sessionId() const {
Eric Laurentde070132010-07-13 04:45:46 -07001285 return mSessionId;
1286 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001287 status_t setEnabled(bool enabled);
Glenn Kastenc59c0042012-02-02 14:06:11 -08001288 bool isEnabled() const;
1289 bool isProcessEnabled() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001290
1291 void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; }
1292 int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; }
1293 void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; }
1294 int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; }
Eric Laurentde070132010-07-13 04:45:46 -07001295 void setChain(const wp<EffectChain>& chain) { mChain = chain; }
1296 void setThread(const wp<ThreadBase>& thread) { mThread = thread; }
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001297 const wp<ThreadBase>& thread() { return mThread; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001298
Glenn Kasten435dbe62012-01-30 10:15:48 -08001299 status_t addHandle(const sp<EffectHandle>& handle);
Glenn Kasten58123c32012-02-03 10:32:24 -08001300 void disconnect(const wp<EffectHandle>& handle, bool unpinIfLast);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001301 size_t removeHandle (const wp<EffectHandle>& handle);
1302
1303 effect_descriptor_t& desc() { return mDescriptor; }
1304 wp<EffectChain>& chain() { return mChain; }
1305
1306 status_t setDevice(uint32_t device);
1307 status_t setVolume(uint32_t *left, uint32_t *right, bool controller);
Glenn Kastenf78aee72012-01-04 11:00:47 -08001308 status_t setMode(audio_mode_t mode);
Eric Laurentec35a142011-10-05 17:42:25 -07001309 status_t start();
Eric Laurentec437d82011-07-26 20:54:46 -07001310 status_t stop();
Eric Laurent59255e42011-07-27 19:49:51 -07001311 void setSuspended(bool suspended);
Glenn Kastena3a85482012-01-04 11:01:11 -08001312 bool suspended() const;
Eric Laurent59255e42011-07-27 19:49:51 -07001313
1314 sp<EffectHandle> controlHandle();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001315
Glenn Kastenc59c0042012-02-02 14:06:11 -08001316 bool isPinned() const { return mPinned; }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001317 void unPin() { mPinned = false; }
1318
Mathias Agopian65ab4712010-07-14 17:59:35 -07001319 status_t dump(int fd, const Vector<String16>& args);
1320
1321 protected:
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001322 friend class EffectHandle;
1323 friend class AudioFlinger;
1324 bool mPinned;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001325
1326 // Maximum time allocated to effect engines to complete the turn off sequence
1327 static const uint32_t MAX_DISABLE_TIME_MS = 10000;
1328
1329 EffectModule(const EffectModule&);
1330 EffectModule& operator = (const EffectModule&);
1331
1332 status_t start_l();
1333 status_t stop_l();
1334
Glenn Kastena3a85482012-01-04 11:01:11 -08001335mutable Mutex mLock; // mutex for process, commands and handles list protection
Mathias Agopian65ab4712010-07-14 17:59:35 -07001336 wp<ThreadBase> mThread; // parent thread
1337 wp<EffectChain> mChain; // parent effect chain
1338 int mId; // this instance unique ID
1339 int mSessionId; // audio session ID
1340 effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
1341 effect_config_t mConfig; // input and output audio configuration
Eric Laurente1315cf2011-05-17 19:16:02 -07001342 effect_handle_t mEffectInterface; // Effect module C API
Glenn Kasten28243dd2012-01-26 13:43:46 -08001343 status_t mStatus; // initialization status
1344 effect_state mState; // current activation state
Mathias Agopian65ab4712010-07-14 17:59:35 -07001345 Vector< wp<EffectHandle> > mHandles; // list of client handles
Glenn Kasten99e53b82012-01-19 08:59:58 -08001346 // First handle in mHandles has highest priority and controls the effect module
Mathias Agopian65ab4712010-07-14 17:59:35 -07001347 uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after
1348 // sending disable command.
1349 uint32_t mDisableWaitCnt; // current process() calls count during disable period.
Eric Laurent59255e42011-07-27 19:49:51 -07001350 bool mSuspended; // effect is suspended: temporarily disabled by framework
Mathias Agopian65ab4712010-07-14 17:59:35 -07001351 };
1352
1353 // The EffectHandle class implements the IEffect interface. It provides resources
1354 // to receive parameter updates, keeps track of effect control
1355 // ownership and state and has a pointer to the EffectModule object it is controlling.
1356 // There is one EffectHandle object for each application controlling (or using)
1357 // an effect module.
1358 // The EffectHandle is obtained by calling AudioFlinger::createEffect().
1359 class EffectHandle: public android::BnEffect {
1360 public:
1361
1362 EffectHandle(const sp<EffectModule>& effect,
1363 const sp<AudioFlinger::Client>& client,
1364 const sp<IEffectClient>& effectClient,
1365 int32_t priority);
1366 virtual ~EffectHandle();
1367
1368 // IEffect
1369 virtual status_t enable();
1370 virtual status_t disable();
Eric Laurent25f43952010-07-28 05:40:18 -07001371 virtual status_t command(uint32_t cmdCode,
1372 uint32_t cmdSize,
1373 void *pCmdData,
1374 uint32_t *replySize,
1375 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001376 virtual void disconnect();
Glenn Kasten58123c32012-02-03 10:32:24 -08001377 private:
1378 void disconnect(bool unpinIfLast);
1379 public:
Glenn Kastenc59c0042012-02-02 14:06:11 -08001380 virtual sp<IMemory> getCblk() const { return mCblkMemory; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001381 virtual status_t onTransact(uint32_t code, const Parcel& data,
1382 Parcel* reply, uint32_t flags);
1383
1384
1385 // Give or take control of effect module
Eric Laurent59255e42011-07-27 19:49:51 -07001386 // - hasControl: true if control is given, false if removed
1387 // - signal: true client app should be signaled of change, false otherwise
1388 // - enabled: state of the effect when control is passed
1389 void setControl(bool hasControl, bool signal, bool enabled);
Eric Laurent25f43952010-07-28 05:40:18 -07001390 void commandExecuted(uint32_t cmdCode,
1391 uint32_t cmdSize,
1392 void *pCmdData,
1393 uint32_t replySize,
1394 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001395 void setEnabled(bool enabled);
Glenn Kastenc59c0042012-02-02 14:06:11 -08001396 bool enabled() const { return mEnabled; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001397
1398 // Getters
Glenn Kastenc59c0042012-02-02 14:06:11 -08001399 int id() const { return mEffect->id(); }
1400 int priority() const { return mPriority; }
1401 bool hasControl() const { return mHasControl; }
1402 sp<EffectModule> effect() const { return mEffect; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001403
1404 void dump(char* buffer, size_t size);
1405
1406 protected:
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001407 friend class AudioFlinger;
1408 friend class EffectModule;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001409 EffectHandle(const EffectHandle&);
1410 EffectHandle& operator =(const EffectHandle&);
1411
1412 sp<EffectModule> mEffect; // pointer to controlled EffectModule
1413 sp<IEffectClient> mEffectClient; // callback interface for client notifications
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001414 /*const*/ sp<Client> mClient; // client for shared memory allocation, see disconnect()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001415 sp<IMemory> mCblkMemory; // shared memory for control block
1416 effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory
1417 uint8_t* mBuffer; // pointer to parameter area in shared memory
1418 int mPriority; // client application priority to control the effect
1419 bool mHasControl; // true if this handle is controlling the effect
Eric Laurent59255e42011-07-27 19:49:51 -07001420 bool mEnabled; // cached enable state: needed when the effect is
1421 // restored after being suspended
Mathias Agopian65ab4712010-07-14 17:59:35 -07001422 };
1423
1424 // the EffectChain class represents a group of effects associated to one audio session.
1425 // There can be any number of EffectChain objects per output mixer thread (PlaybackThread).
1426 // The EffecChain with session ID 0 contains global effects applied to the output mix.
1427 // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks)
1428 // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding
1429 // in the effect process order. When attached to a track (session ID != 0), it also provide it's own
1430 // input buffer used by the track as accumulation buffer.
1431 class EffectChain: public RefBase {
1432 public:
1433 EffectChain(const wp<ThreadBase>& wThread, int sessionId);
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001434 EffectChain(ThreadBase *thread, int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001435 virtual ~EffectChain();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001436
Eric Laurent59255e42011-07-27 19:49:51 -07001437 // special key used for an entry in mSuspendedEffects keyed vector
1438 // corresponding to a suspend all request.
1439 static const int kKeyForSuspendAll = 0;
1440
Eric Laurent544fe9b2011-11-11 15:42:52 -08001441 // minimum duration during which we force calling effect process when last track on
1442 // a session is stopped or removed to allow effect tail to be rendered
1443 static const int kProcessTailDurationMs = 1000;
1444
Mathias Agopian65ab4712010-07-14 17:59:35 -07001445 void process_l();
1446
1447 void lock() {
1448 mLock.lock();
1449 }
1450 void unlock() {
1451 mLock.unlock();
1452 }
1453
Eric Laurentde070132010-07-13 04:45:46 -07001454 status_t addEffect_l(const sp<EffectModule>& handle);
Eric Laurentcab11242010-07-15 12:50:15 -07001455 size_t removeEffect_l(const sp<EffectModule>& handle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001456
Glenn Kastenc59c0042012-02-02 14:06:11 -08001457 int sessionId() const { return mSessionId; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001458 void setSessionId(int sessionId) { mSessionId = sessionId; }
Eric Laurentde070132010-07-13 04:45:46 -07001459
Eric Laurentcab11242010-07-15 12:50:15 -07001460 sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor);
1461 sp<EffectModule> getEffectFromId_l(int id);
Eric Laurent59255e42011-07-27 19:49:51 -07001462 sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type);
Eric Laurentcab11242010-07-15 12:50:15 -07001463 bool setVolume_l(uint32_t *left, uint32_t *right);
1464 void setDevice_l(uint32_t device);
Glenn Kastenf78aee72012-01-04 11:00:47 -08001465 void setMode_l(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001466
Mathias Agopian65ab4712010-07-14 17:59:35 -07001467 void setInBuffer(int16_t *buffer, bool ownsBuffer = false) {
1468 mInBuffer = buffer;
1469 mOwnInBuffer = ownsBuffer;
1470 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001471 int16_t *inBuffer() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001472 return mInBuffer;
1473 }
1474 void setOutBuffer(int16_t *buffer) {
1475 mOutBuffer = buffer;
1476 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001477 int16_t *outBuffer() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001478 return mOutBuffer;
1479 }
1480
Eric Laurentb469b942011-05-09 12:09:06 -07001481 void incTrackCnt() { android_atomic_inc(&mTrackCnt); }
1482 void decTrackCnt() { android_atomic_dec(&mTrackCnt); }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001483 int32_t trackCnt() const { return mTrackCnt;}
Eric Laurentb469b942011-05-09 12:09:06 -07001484
Eric Laurent544fe9b2011-11-11 15:42:52 -08001485 void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt);
1486 mTailBufferCount = mMaxTailBuffers; }
Eric Laurentb469b942011-05-09 12:09:06 -07001487 void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001488 int32_t activeTrackCnt() const { return mActiveTrackCnt;}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001489
Glenn Kastenc59c0042012-02-02 14:06:11 -08001490 uint32_t strategy() const { return mStrategy; }
Eric Laurentde070132010-07-13 04:45:46 -07001491 void setStrategy(uint32_t strategy)
1492 { mStrategy = strategy; }
1493
Eric Laurent59255e42011-07-27 19:49:51 -07001494 // suspend effect of the given type
1495 void setEffectSuspended_l(const effect_uuid_t *type,
1496 bool suspend);
1497 // suspend all eligible effects
1498 void setEffectSuspendedAll_l(bool suspend);
1499 // check if effects should be suspend or restored when a given effect is enable or disabled
Eric Laurenta85a74a2011-10-19 11:44:54 -07001500 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
Eric Laurent59255e42011-07-27 19:49:51 -07001501 bool enabled);
1502
Mathias Agopian65ab4712010-07-14 17:59:35 -07001503 status_t dump(int fd, const Vector<String16>& args);
1504
1505 protected:
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001506 friend class AudioFlinger;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001507 EffectChain(const EffectChain&);
1508 EffectChain& operator =(const EffectChain&);
1509
Eric Laurent59255e42011-07-27 19:49:51 -07001510 class SuspendedEffectDesc : public RefBase {
1511 public:
1512 SuspendedEffectDesc() : mRefCount(0) {}
1513
1514 int mRefCount;
1515 effect_uuid_t mType;
1516 wp<EffectModule> mEffect;
1517 };
1518
1519 // get a list of effect modules to suspend when an effect of the type
1520 // passed is enabled.
Glenn Kastend0539712012-01-30 12:56:03 -08001521 void getSuspendEligibleEffects(Vector< sp<EffectModule> > &effects);
1522
Eric Laurent59255e42011-07-27 19:49:51 -07001523 // get an effect module if it is currently enable
1524 sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type);
Eric Laurentdb7c0792011-08-10 10:37:50 -07001525 // true if the effect whose descriptor is passed can be suspended
1526 // OEMs can modify the rules implemented in this method to exclude specific effect
1527 // types or implementations from the suspend/restore mechanism.
1528 bool isEffectEligibleForSuspend(const effect_descriptor_t& desc);
Eric Laurent59255e42011-07-27 19:49:51 -07001529
Mathias Agopian65ab4712010-07-14 17:59:35 -07001530 wp<ThreadBase> mThread; // parent mixer thread
1531 Mutex mLock; // mutex protecting effect list
1532 Vector<sp<EffectModule> > mEffects; // list of effect modules
1533 int mSessionId; // audio session ID
1534 int16_t *mInBuffer; // chain input buffer
1535 int16_t *mOutBuffer; // chain output buffer
Eric Laurentb469b942011-05-09 12:09:06 -07001536 volatile int32_t mActiveTrackCnt; // number of active tracks connected
1537 volatile int32_t mTrackCnt; // number of tracks connected
Eric Laurent544fe9b2011-11-11 15:42:52 -08001538 int32_t mTailBufferCount; // current effect tail buffer count
1539 int32_t mMaxTailBuffers; // maximum effect tail buffers
Mathias Agopian65ab4712010-07-14 17:59:35 -07001540 bool mOwnInBuffer; // true if the chain owns its input buffer
Eric Laurentcab11242010-07-15 12:50:15 -07001541 int mVolumeCtrlIdx; // index of insert effect having control over volume
1542 uint32_t mLeftVolume; // previous volume on left channel
1543 uint32_t mRightVolume; // previous volume on right channel
Eric Laurentf997cab2010-07-19 06:24:46 -07001544 uint32_t mNewLeftVolume; // new volume on left channel
1545 uint32_t mNewRightVolume; // new volume on right channel
Eric Laurentde070132010-07-13 04:45:46 -07001546 uint32_t mStrategy; // strategy for this effect chain
Eric Laurent59255e42011-07-27 19:49:51 -07001547 // mSuspendedEffects lists all effect currently suspended in the chain
1548 // use effect type UUID timelow field as key. There is no real risk of identical
1549 // timeLow fields among effect type UUIDs.
1550 KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001551 };
1552
Glenn Kastenaed850d2012-01-26 09:46:34 -08001553 // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
1554 // For emphasis, we could also make all pointers to them be "const *",
1555 // but that would clutter the code unnecessarily.
1556
Dima Zavin799a70e2011-04-18 16:57:27 -07001557 struct AudioStreamOut {
Glenn Kastenaed850d2012-01-26 09:46:34 -08001558 audio_hw_device_t* const hwDev;
1559 audio_stream_out_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -07001560
1561 AudioStreamOut(audio_hw_device_t *dev, audio_stream_out_t *out) :
1562 hwDev(dev), stream(out) {}
1563 };
1564
1565 struct AudioStreamIn {
Glenn Kastenaed850d2012-01-26 09:46:34 -08001566 audio_hw_device_t* const hwDev;
1567 audio_stream_in_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -07001568
1569 AudioStreamIn(audio_hw_device_t *dev, audio_stream_in_t *in) :
1570 hwDev(dev), stream(in) {}
1571 };
1572
Glenn Kasten99e53b82012-01-19 08:59:58 -08001573 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001574 struct AudioSessionRef {
Glenn Kasten012ca6b2012-03-06 11:22:01 -08001575 AudioSessionRef(int sessionid, pid_t pid) :
1576 mSessionid(sessionid), mPid(pid), mCnt(1) {}
1577 const int mSessionid;
1578 const pid_t mPid;
1579 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001580 };
1581
Mathias Agopian65ab4712010-07-14 17:59:35 -07001582 friend class RecordThread;
1583 friend class PlaybackThread;
1584
John Grossman4ff14ba2012-02-08 16:37:41 -08001585 enum master_volume_support {
1586 // MVS_NONE:
1587 // Audio HAL has no support for master volume, either setting or
1588 // getting. All master volume control must be implemented in SW by the
1589 // AudioFlinger mixing core.
1590 MVS_NONE,
1591
1592 // MVS_SETONLY:
1593 // Audio HAL has support for setting master volume, but not for getting
1594 // master volume (original HAL design did not include a getter).
1595 // AudioFlinger needs to keep track of the last set master volume in
1596 // addition to needing to set an initial, default, master volume at HAL
1597 // load time.
1598 MVS_SETONLY,
1599
1600 // MVS_FULL:
1601 // Audio HAL has support both for setting and getting master volume.
1602 // AudioFlinger should send all set and get master volume requests
1603 // directly to the HAL.
1604 MVS_FULL,
1605 };
1606
Mathias Agopian65ab4712010-07-14 17:59:35 -07001607 mutable Mutex mLock;
1608
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001609 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001610
1611 mutable Mutex mHardwareLock;
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001612
1613 // These two fields are immutable after onFirstRef(), so no lock needed to access
1614 audio_hw_device_t* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07001615 Vector<audio_hw_device_t*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001616
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001617 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001618 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001619 AUDIO_HW_IDLE = 0, // no operation in progress
1620 AUDIO_HW_INIT, // init_check
1621 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
1622 AUDIO_HW_OUTPUT_CLOSE, // unused
1623 AUDIO_HW_INPUT_OPEN, // unused
1624 AUDIO_HW_INPUT_CLOSE, // unused
1625 AUDIO_HW_STANDBY, // unused
1626 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
1627 AUDIO_HW_GET_ROUTING, // unused
1628 AUDIO_HW_SET_ROUTING, // unused
1629 AUDIO_HW_GET_MODE, // unused
1630 AUDIO_HW_SET_MODE, // set_mode
1631 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
1632 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
1633 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
1634 AUDIO_HW_SET_PARAMETER, // set_parameters
1635 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
1636 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
1637 AUDIO_HW_GET_PARAMETER, // get_parameters
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001638 };
1639
Glenn Kastena4454b42012-01-04 11:02:33 -08001640 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -07001641
1642
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001643 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -08001644 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -08001645
1646 // both are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -07001647 float mMasterVolume;
John Grossman4ff14ba2012-02-08 16:37:41 -08001648 float mMasterVolumeSW;
1649 master_volume_support mMasterVolumeSupportLvl;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001650 bool mMasterMute;
1651
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001652 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001653
1654 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kasten99e53b82012-01-19 08:59:58 -08001655 volatile int32_t mNextUniqueId; // updated by android_atomic_inc
Glenn Kastenf78aee72012-01-04 11:00:47 -08001656 audio_mode_t mMode;
Eric Laurentbee53372011-08-29 12:42:48 -07001657 bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001658
Glenn Kasten99e53b82012-01-19 08:59:58 -08001659 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001660 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -08001661
John Grossman4ff14ba2012-02-08 16:37:41 -08001662 float masterVolume_l() const;
1663 float masterVolumeSW_l() const { return mMasterVolumeSW; }
Glenn Kasten98067102011-12-13 11:47:54 -08001664 bool masterMute_l() const { return mMasterMute; }
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001665
1666private:
1667 sp<Client> registerPid_l(pid_t pid); // always returns non-0
1668
Mathias Agopian65ab4712010-07-14 17:59:35 -07001669};
1670
Dima Zavin799a70e2011-04-18 16:57:27 -07001671
Mathias Agopian65ab4712010-07-14 17:59:35 -07001672// ----------------------------------------------------------------------------
1673
1674}; // namespace android
1675
1676#endif // ANDROID_AUDIO_FLINGER_H