blob: 4723cd9288267403899e7796321cb5acdc86b23f [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>
Eric Laurenta4c5a552012-03-29 10:12:40 -070046#include <hardware/audio_policy.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070047
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070048#include <media/AudioBufferProvider.h>
49#include <media/ExtendedAudioBufferProvider.h>
Glenn Kasten58912562012-04-03 10:45:00 -070050#include "FastMixer.h"
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070051#include <media/nbaio/NBAIO.h>
Glenn Kastenc15d6652012-05-30 14:52:57 -070052#include "AudioWatchdog.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
Eric Laurentfeb0db62011-07-22 09:04:31 -070054#include <powermanager/IPowerManager.h>
55
Mathias Agopian65ab4712010-07-14 17:59:35 -070056namespace android {
57
58class audio_track_cblk_t;
59class effect_param_cblk_t;
60class AudioMixer;
61class AudioBuffer;
62class AudioResampler;
Glenn Kasten58912562012-04-03 10:45:00 -070063class FastMixer;
Mathias Agopian65ab4712010-07-14 17:59:35 -070064
Mathias Agopian65ab4712010-07-14 17:59:35 -070065// ----------------------------------------------------------------------------
66
Glenn Kasten53d76db2012-03-08 12:32:47 -080067// AudioFlinger has a hard-coded upper limit of 2 channels for capture and playback.
68// There is support for > 2 channel tracks down-mixed to 2 channel output via a down-mix effect.
69// Adding full support for > 2 channel capture or playback would require more than simply changing
70// this #define. There is an independent hard-coded upper limit in AudioMixer;
71// removing that AudioMixer limit would be necessary but insufficient to support > 2 channels.
72// The macro FCC_2 highlights some (but not all) places where there is are 2-channel assumptions.
73// Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc.
74#define FCC_2 2 // FCC_2 = Fixed Channel Count 2
75
John Grossman4ff14ba2012-02-08 16:37:41 -080076static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
Mathias Agopian65ab4712010-07-14 17:59:35 -070077
Mathias Agopian5462fc92010-07-14 18:41:18 -070078class AudioFlinger :
79 public BinderService<AudioFlinger>,
80 public BnAudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -070081{
Glenn Kasten19986612012-03-09 12:07:30 -080082 friend class BinderService<AudioFlinger>; // for AudioFlinger()
Mathias Agopian65ab4712010-07-14 17:59:35 -070083public:
Glenn Kasten54c3b662012-01-06 07:46:30 -080084 static const char* getServiceName() { return "media.audio_flinger"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -070085
86 virtual status_t dump(int fd, const Vector<String16>& args);
87
Glenn Kasten2f732eb2012-01-26 09:48:03 -080088 // IAudioFlinger interface, in binder opcode order
Mathias Agopian65ab4712010-07-14 17:59:35 -070089 virtual sp<IAudioTrack> createTrack(
90 pid_t pid,
Glenn Kastenfff6d712012-01-12 16:38:12 -080091 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -070092 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -080093 audio_format_t format,
Glenn Kastendd8104c2012-07-02 12:42:44 -070094 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -070095 int frameCount,
Glenn Kastena075db42012-03-06 11:22:44 -080096 IAudioFlinger::track_flags_t flags,
Mathias Agopian65ab4712010-07-14 17:59:35 -070097 const sp<IMemory>& sharedBuffer,
Glenn Kasten72ef00d2012-01-17 11:09:42 -080098 audio_io_handle_t output,
Glenn Kasten3acbd052012-02-28 10:39:56 -080099 pid_t tid,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700100 int *sessionId,
101 status_t *status);
102
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800103 virtual sp<IAudioRecord> openRecord(
104 pid_t pid,
105 audio_io_handle_t input,
106 uint32_t sampleRate,
107 audio_format_t format,
Glenn Kastendd8104c2012-07-02 12:42:44 -0700108 audio_channel_mask_t channelMask,
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800109 int frameCount,
Glenn Kastena075db42012-03-06 11:22:44 -0800110 IAudioFlinger::track_flags_t flags,
Glenn Kasten1879fff2012-07-11 15:36:59 -0700111 pid_t tid,
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800112 int *sessionId,
113 status_t *status);
114
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800115 virtual uint32_t sampleRate(audio_io_handle_t output) const;
116 virtual int channelCount(audio_io_handle_t output) const;
117 virtual audio_format_t format(audio_io_handle_t output) const;
118 virtual size_t frameCount(audio_io_handle_t output) const;
119 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700120
121 virtual status_t setMasterVolume(float value);
122 virtual status_t setMasterMute(bool muted);
123
124 virtual float masterVolume() const;
125 virtual bool masterMute() const;
126
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800127 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
128 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800129 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700130
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800131 virtual float streamVolume(audio_stream_type_t stream,
132 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800133 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700134
Glenn Kastenf78aee72012-01-04 11:00:47 -0800135 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700136
137 virtual status_t setMicMute(bool state);
138 virtual bool getMicMute() const;
139
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800140 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
141 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700142
143 virtual void registerClient(const sp<IAudioFlingerClient>& client);
144
Glenn Kastendd8104c2012-07-02 12:42:44 -0700145 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
146 audio_channel_mask_t channelMask) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700147
Eric Laurenta4c5a552012-03-29 10:12:40 -0700148 virtual audio_io_handle_t openOutput(audio_module_handle_t module,
149 audio_devices_t *pDevices,
150 uint32_t *pSamplingRate,
151 audio_format_t *pFormat,
152 audio_channel_mask_t *pChannelMask,
153 uint32_t *pLatencyMs,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700154 audio_output_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700155
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800156 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
157 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700158
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800159 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700160
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800161 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700162
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800163 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700164
Eric Laurenta4c5a552012-03-29 10:12:40 -0700165 virtual audio_io_handle_t openInput(audio_module_handle_t module,
166 audio_devices_t *pDevices,
167 uint32_t *pSamplingRate,
168 audio_format_t *pFormat,
169 audio_channel_mask_t *pChannelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700170
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800171 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700172
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800173 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700174
175 virtual status_t setVoiceVolume(float volume);
176
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800177 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
178 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700179
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800180 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const;
181
Mathias Agopian65ab4712010-07-14 17:59:35 -0700182 virtual int newAudioSessionId();
183
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700184 virtual void acquireAudioSessionId(int audioSession);
185
186 virtual void releaseAudioSessionId(int audioSession);
187
Glenn Kastenf587ba52012-01-26 16:25:10 -0800188 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700189
Glenn Kastenf587ba52012-01-26 16:25:10 -0800190 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700191
Glenn Kasten5e92a782012-01-30 07:40:52 -0800192 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800193 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700194
195 virtual sp<IEffect> createEffect(pid_t pid,
196 effect_descriptor_t *pDesc,
197 const sp<IEffectClient>& effectClient,
198 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800199 audio_io_handle_t io,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700200 int sessionId,
201 status_t *status,
202 int *id,
203 int *enabled);
204
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800205 virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
206 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700207
Eric Laurenta4c5a552012-03-29 10:12:40 -0700208 virtual audio_module_handle_t loadHwModule(const char *name);
209
Mathias Agopian65ab4712010-07-14 17:59:35 -0700210 virtual status_t onTransact(
211 uint32_t code,
212 const Parcel& data,
213 Parcel* reply,
214 uint32_t flags);
215
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800216 // end of IAudioFlinger interface
217
Eric Laurenta011e352012-03-29 15:51:43 -0700218 class SyncEvent;
219
220 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
221
222 class SyncEvent : public RefBase {
223 public:
224 SyncEvent(AudioSystem::sync_event_t type,
225 int triggerSession,
226 int listenerSession,
227 sync_event_callback_t callBack,
228 void *cookie)
229 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
230 mCallback(callBack), mCookie(cookie)
231 {}
232
233 virtual ~SyncEvent() {}
234
235 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
Glenn Kasten106e8a42012-08-02 13:37:12 -0700236 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
237 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
Eric Laurenta011e352012-03-29 15:51:43 -0700238 AudioSystem::sync_event_t type() const { return mType; }
239 int triggerSession() const { return mTriggerSession; }
240 int listenerSession() const { return mListenerSession; }
241 void *cookie() const { return mCookie; }
242
243 private:
244 const AudioSystem::sync_event_t mType;
245 const int mTriggerSession;
246 const int mListenerSession;
247 sync_event_callback_t mCallback;
248 void * const mCookie;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700249 mutable Mutex mLock;
Eric Laurenta011e352012-03-29 15:51:43 -0700250 };
251
252 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
253 int triggerSession,
254 int listenerSession,
255 sync_event_callback_t callBack,
256 void *cookie);
Eric Laurent717e1282012-06-29 16:36:52 -0700257
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800258private:
John Grossmanee578c02012-07-23 17:05:46 -0700259 class AudioHwDevice; // fwd declaration for findSuitableHwDev_l
260
Glenn Kastenf78aee72012-01-04 11:00:47 -0800261 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700262
Glenn Kastenc59c0042012-02-02 14:06:11 -0800263 bool btNrecIsOff() const { return mBtNrecIsOff; }
Eric Laurent59bd0da2011-08-01 09:52:20 -0700264
Mathias Agopian65ab4712010-07-14 17:59:35 -0700265 AudioFlinger();
266 virtual ~AudioFlinger();
267
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800268 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
269 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? NO_INIT : NO_ERROR; }
270
Glenn Kasten000f0e32012-03-01 17:10:56 -0800271 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700272 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800273
John Grossmanee578c02012-07-23 17:05:46 -0700274 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module, audio_devices_t devices);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700275 void purgeStaleEffects_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700276
Glenn Kasten66fcab92012-02-24 14:59:21 -0800277 // standby delay for MIXER and DUPLICATING playback threads is read from property
278 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
John Grossman4ff14ba2012-02-08 16:37:41 -0800279 static nsecs_t mStandbyTimeInNsecs;
280
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700281 // Internal dump utilities.
282 void dumpPermissionDenial(int fd, const Vector<String16>& args);
283 void dumpClients(int fd, const Vector<String16>& args);
284 void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700285
286 // --- Client ---
287 class Client : public RefBase {
288 public:
289 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
290 virtual ~Client();
Glenn Kasten435dbe62012-01-30 10:15:48 -0800291 sp<MemoryDealer> heap() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700292 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800293 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700294
John Grossman4ff14ba2012-02-08 16:37:41 -0800295 bool reserveTimedTrack();
296 void releaseTimedTrack();
297
Mathias Agopian65ab4712010-07-14 17:59:35 -0700298 private:
299 Client(const Client&);
300 Client& operator = (const Client&);
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800301 const sp<AudioFlinger> mAudioFlinger;
302 const sp<MemoryDealer> mMemoryDealer;
303 const pid_t mPid;
John Grossman4ff14ba2012-02-08 16:37:41 -0800304
305 Mutex mTimedTrackLock;
306 int mTimedTrackCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700307 };
308
309 // --- Notification Client ---
310 class NotificationClient : public IBinder::DeathRecipient {
311 public:
312 NotificationClient(const sp<AudioFlinger>& audioFlinger,
313 const sp<IAudioFlingerClient>& client,
314 pid_t pid);
315 virtual ~NotificationClient();
316
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800317 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700318
319 // IBinder::DeathRecipient
320 virtual void binderDied(const wp<IBinder>& who);
321
322 private:
323 NotificationClient(const NotificationClient&);
324 NotificationClient& operator = (const NotificationClient&);
325
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800326 const sp<AudioFlinger> mAudioFlinger;
327 const pid_t mPid;
328 const sp<IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700329 };
330
331 class TrackHandle;
332 class RecordHandle;
333 class RecordThread;
334 class PlaybackThread;
335 class MixerThread;
336 class DirectOutputThread;
337 class DuplicatingThread;
338 class Track;
339 class RecordTrack;
340 class EffectModule;
341 class EffectHandle;
342 class EffectChain;
Dima Zavin799a70e2011-04-18 16:57:27 -0700343 struct AudioStreamOut;
344 struct AudioStreamIn;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700345
346 class ThreadBase : public Thread {
347 public:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700348
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800349 enum type_t {
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700350 MIXER, // Thread class is MixerThread
351 DIRECT, // Thread class is DirectOutputThread
352 DUPLICATING, // Thread class is DuplicatingThread
353 RECORD // Thread class is RecordThread
354 };
355
Glenn Kastenbb4350d2012-07-03 15:56:38 -0700356 ThreadBase (const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, audio_devices_t device, type_t type);
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800357 virtual ~ThreadBase();
358
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700359 void dumpBase(int fd, const Vector<String16>& args);
360 void dumpEffectChains(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700361
Eric Laurentfeb0db62011-07-22 09:04:31 -0700362 void clearPowerManager();
363
Mathias Agopian65ab4712010-07-14 17:59:35 -0700364 // base for record and playback
Glenn Kasten288ed212012-04-25 17:52:27 -0700365 class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700366
367 public:
368 enum track_state {
369 IDLE,
370 TERMINATED,
Eric Laurent29864602012-05-08 18:57:51 -0700371 FLUSHED,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700372 STOPPED,
Glenn Kastend08f48c2012-05-01 18:14:02 -0700373 // next 2 states are currently used for fast tracks only
374 STOPPING_1, // waiting for first underrun
375 STOPPING_2, // waiting for presentation complete
Mathias Agopian65ab4712010-07-14 17:59:35 -0700376 RESUMING,
377 ACTIVE,
378 PAUSING,
379 PAUSED
380 };
381
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800382 TrackBase(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700383 const sp<Client>& client,
384 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800385 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -0700386 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700387 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700388 const sp<IMemory>& sharedBuffer,
389 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800390 virtual ~TrackBase();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700391
Glenn Kasten0ec23ce2012-07-10 12:56:08 -0700392 virtual status_t start(AudioSystem::sync_event_t event,
393 int triggerSession) = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700394 virtual void stop() = 0;
Glenn Kastenc59c0042012-02-02 14:06:11 -0800395 sp<IMemory> getCblk() const { return mCblkMemory; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700396 audio_track_cblk_t* cblk() const { return mCblk; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800397 int sessionId() const { return mSessionId; }
Eric Laurenta011e352012-03-29 15:51:43 -0700398 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700399
400 protected:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700401 TrackBase(const TrackBase&);
402 TrackBase& operator = (const TrackBase&);
403
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800404 // AudioBufferProvider interface
405 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700406 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
407
Glenn Kasten288ed212012-04-25 17:52:27 -0700408 // ExtendedAudioBufferProvider interface is only needed for Track,
409 // but putting it in TrackBase avoids the complexity of virtual inheritance
410 virtual size_t framesReady() const { return SIZE_MAX; }
411
Glenn Kasten58f30212012-01-12 12:27:51 -0800412 audio_format_t format() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700413 return mFormat;
414 }
415
Glenn Kastenc59c0042012-02-02 14:06:11 -0800416 int channelCount() const { return mChannelCount; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700417
Glenn Kasten254af182012-07-03 14:59:05 -0700418 audio_channel_mask_t channelMask() const { return mChannelMask; }
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700419
Glenn Kastenc59c0042012-02-02 14:06:11 -0800420 int sampleRate() const; // FIXME inline after cblk sr moved
Mathias Agopian65ab4712010-07-14 17:59:35 -0700421
Glenn Kasten66488212012-06-21 12:57:20 -0700422 // Return a pointer to the start of a contiguous slice of the track buffer.
423 // Parameter 'offset' is the requested start position, expressed in
424 // monotonically increasing frame units relative to the track epoch.
425 // Parameter 'frames' is the requested length, also in frame units.
426 // Always returns non-NULL. It is the caller's responsibility to
427 // verify that this will be successful; the result of calling this
428 // function with invalid 'offset' or 'frames' is undefined.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700429 void* getBuffer(uint32_t offset, uint32_t frames) const;
430
431 bool isStopped() const {
Eric Laurent29864602012-05-08 18:57:51 -0700432 return (mState == STOPPED || mState == FLUSHED);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700433 }
434
Glenn Kastend08f48c2012-05-01 18:14:02 -0700435 // for fast tracks only
436 bool isStopping() const {
437 return mState == STOPPING_1 || mState == STOPPING_2;
438 }
439 bool isStopping_1() const {
440 return mState == STOPPING_1;
441 }
442 bool isStopping_2() const {
443 return mState == STOPPING_2;
444 }
445
Mathias Agopian65ab4712010-07-14 17:59:35 -0700446 bool isTerminated() const {
447 return mState == TERMINATED;
448 }
449
450 bool step();
451 void reset();
452
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800453 const wp<ThreadBase> mThread;
454 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700455 sp<IMemory> mCblkMemory;
456 audio_track_cblk_t* mCblk;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700457 void* mBuffer; // start of track buffer, typically in shared memory
458 void* mBufferEnd; // &mBuffer[mFrameCount * frameSize], where frameSize
459 // is based on mChannelCount and 16-bit samples
Mathias Agopian65ab4712010-07-14 17:59:35 -0700460 uint32_t mFrameCount;
461 // we don't really need a lock for these
Glenn Kastenb853e982012-01-26 13:39:18 -0800462 track_state mState;
Glenn Kasten58912562012-04-03 10:45:00 -0700463 const uint32_t mSampleRate; // initial sample rate only; for tracks which
464 // support dynamic rates, the current value is in control block
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800465 const audio_format_t mFormat;
Glenn Kasten5cf034d2012-02-21 10:35:56 -0800466 bool mStepServerFailed;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800467 const int mSessionId;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700468 uint8_t mChannelCount;
Glenn Kasten254af182012-07-03 14:59:05 -0700469 audio_channel_mask_t mChannelMask;
Eric Laurenta011e352012-03-29 15:51:43 -0700470 Vector < sp<SyncEvent> >mSyncEvents;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700471 };
472
473 class ConfigEvent {
474 public:
475 ConfigEvent() : mEvent(0), mParam(0) {}
476
477 int mEvent;
478 int mParam;
479 };
480
Eric Laurentfeb0db62011-07-22 09:04:31 -0700481 class PMDeathRecipient : public IBinder::DeathRecipient {
482 public:
483 PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
484 virtual ~PMDeathRecipient() {}
485
486 // IBinder::DeathRecipient
487 virtual void binderDied(const wp<IBinder>& who);
488
489 private:
490 PMDeathRecipient(const PMDeathRecipient&);
491 PMDeathRecipient& operator = (const PMDeathRecipient&);
492
493 wp<ThreadBase> mThread;
494 };
495
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700496 virtual status_t initCheck() const = 0;
Glenn Kasten01542f22012-07-02 12:46:15 -0700497
498 // static externally-visible
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800499 type_t type() const { return mType; }
Glenn Kasten01542f22012-07-02 12:46:15 -0700500 audio_io_handle_t id() const { return mId;}
501
502 // dynamic externally-visible
Glenn Kastenc59c0042012-02-02 14:06:11 -0800503 uint32_t sampleRate() const { return mSampleRate; }
504 int channelCount() const { return mChannelCount; }
Glenn Kasten254af182012-07-03 14:59:05 -0700505 audio_channel_mask_t channelMask() const { return mChannelMask; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800506 audio_format_t format() const { return mFormat; }
Glenn Kasten58912562012-04-03 10:45:00 -0700507 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
508 // and returns the normal mix buffer's frame count. No API for HAL frame count.
509 size_t frameCount() const { return mNormalFrameCount; }
Glenn Kasten01542f22012-07-02 12:46:15 -0700510
Glenn Kastenb28686f2012-01-06 08:39:38 -0800511 // Should be "virtual status_t requestExitAndWait()" and override same
512 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700513 void exit();
514 virtual bool checkForNewParameters_l() = 0;
515 virtual status_t setParameters(const String8& keyValuePairs);
516 virtual String8 getParameters(const String8& keys) = 0;
517 virtual void audioConfigChanged_l(int event, int param = 0) = 0;
518 void sendConfigEvent(int event, int param = 0);
519 void sendConfigEvent_l(int event, int param = 0);
520 void processConfigEvents();
Glenn Kasten01542f22012-07-02 12:46:15 -0700521
522 // see note at declaration of mStandby and mDevice
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800523 bool standby() const { return mStandby; }
Glenn Kasten01542f22012-07-02 12:46:15 -0700524 audio_devices_t device() const { return mDevice; }
525
Glenn Kasten0bf65bd2012-02-28 18:32:53 -0800526 virtual audio_stream_t* stream() const = 0;
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700527
528 sp<EffectHandle> createEffect_l(
529 const sp<AudioFlinger::Client>& client,
530 const sp<IEffectClient>& effectClient,
531 int32_t priority,
532 int sessionId,
533 effect_descriptor_t *desc,
534 int *enabled,
535 status_t *status);
536 void disconnectEffect(const sp< EffectModule>& effect,
Eric Laurenta5f44eb2012-06-25 11:38:29 -0700537 EffectHandle *handle,
Glenn Kasten58123c32012-02-03 10:32:24 -0800538 bool unpinIfLast);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700539
540 // return values for hasAudioSession (bit field)
541 enum effect_state {
542 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
543 // effect
544 TRACK_SESSION = 0x2 // the audio session corresponds to at least one
545 // track
546 };
547
548 // get effect chain corresponding to session Id.
549 sp<EffectChain> getEffectChain(int sessionId);
550 // same as getEffectChain() but must be called with ThreadBase mutex locked
Glenn Kasten106e8a42012-08-02 13:37:12 -0700551 sp<EffectChain> getEffectChain_l(int sessionId) const;
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700552 // add an effect chain to the chain list (mEffectChains)
553 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
554 // remove an effect chain from the chain list (mEffectChains)
555 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
Glenn Kastend805b712012-02-24 15:42:48 -0800556 // lock all effect chains Mutexes. Must be called before releasing the
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700557 // ThreadBase mutex before processing the mixer and effects. This guarantees the
558 // integrity of the chains during the process.
Glenn Kastend805b712012-02-24 15:42:48 -0800559 // Also sets the parameter 'effectChains' to current value of mEffectChains.
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700560 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700561 // unlock effect chains after process
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700562 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700563 // set audio mode to all effect chains
Glenn Kastenf78aee72012-01-04 11:00:47 -0800564 void setMode(audio_mode_t mode);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700565 // get effect module with corresponding ID on specified audio session
Eric Laurent717e1282012-06-29 16:36:52 -0700566 sp<AudioFlinger::EffectModule> getEffect(int sessionId, int effectId);
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700567 sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId);
568 // add and effect module. Also creates the effect chain is none exists for
569 // the effects audio session
570 status_t addEffect_l(const sp< EffectModule>& effect);
571 // remove and effect module. Also removes the effect chain is this was the last
572 // effect
573 void removeEffect_l(const sp< EffectModule>& effect);
574 // detach all tracks connected to an auxiliary effect
575 virtual void detachAuxEffect_l(int effectId) {}
576 // returns either EFFECT_SESSION if effects on this audio session exist in one
577 // chain, or TRACK_SESSION if tracks on this audio session exist, or both
Glenn Kasten106e8a42012-08-02 13:37:12 -0700578 virtual uint32_t hasAudioSession(int sessionId) const = 0;
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700579 // the value returned by default implementation is not important as the
580 // strategy is only meaningful for PlaybackThread which implements this method
581 virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700582
Eric Laurent59255e42011-07-27 19:49:51 -0700583 // suspend or restore effect according to the type of effect passed. a NULL
584 // type pointer means suspend all effects in the session
585 void setEffectSuspended(const effect_uuid_t *type,
586 bool suspend,
587 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
588 // check if some effects must be suspended/restored when an effect is enabled
589 // or disabled
Eric Laurenta85a74a2011-10-19 11:44:54 -0700590 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
Eric Laurent59255e42011-07-27 19:49:51 -0700591 bool enabled,
592 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
Eric Laurenta85a74a2011-10-19 11:44:54 -0700593 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
594 bool enabled,
595 int sessionId = AUDIO_SESSION_OUTPUT_MIX);
Eric Laurenta011e352012-03-29 15:51:43 -0700596
597 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700598 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
Eric Laurenta011e352012-03-29 15:51:43 -0700599
600
Mathias Agopian65ab4712010-07-14 17:59:35 -0700601 mutable Mutex mLock;
602
603 protected:
604
Eric Laurent59255e42011-07-27 19:49:51 -0700605 // entry describing an effect being suspended in mSuspendedSessions keyed vector
606 class SuspendedSessionDesc : public RefBase {
607 public:
608 SuspendedSessionDesc() : mRefCount(0) {}
609
610 int mRefCount; // number of active suspend requests
611 effect_uuid_t mType; // effect type UUID
612 };
613
Eric Laurentfeb0db62011-07-22 09:04:31 -0700614 void acquireWakeLock();
615 void acquireWakeLock_l();
616 void releaseWakeLock();
617 void releaseWakeLock_l();
Eric Laurent59255e42011-07-27 19:49:51 -0700618 void setEffectSuspended_l(const effect_uuid_t *type,
619 bool suspend,
Glenn Kasten0a7af182012-07-09 16:09:19 -0700620 int sessionId);
Eric Laurent59255e42011-07-27 19:49:51 -0700621 // updated mSuspendedSessions when an effect suspended or restored
622 void updateSuspendedSessions_l(const effect_uuid_t *type,
623 bool suspend,
624 int sessionId);
625 // check if some effects must be suspended when an effect chain is added
626 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
Eric Laurentfeb0db62011-07-22 09:04:31 -0700627
Glenn Kasten19986612012-03-09 12:07:30 -0800628 friend class AudioFlinger; // for mEffectChains
Mathias Agopian65ab4712010-07-14 17:59:35 -0700629
Glenn Kasten23bb8be2012-01-26 10:38:26 -0800630 const type_t mType;
Glenn Kastencbc52bf2012-03-01 09:21:37 -0800631
632 // Used by parameters, config events, addTrack_l, exit
Mathias Agopian65ab4712010-07-14 17:59:35 -0700633 Condition mWaitWorkCV;
Glenn Kastencbc52bf2012-03-01 09:21:37 -0800634
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800635 const sp<AudioFlinger> mAudioFlinger;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700636 uint32_t mSampleRate;
Glenn Kasten58912562012-04-03 10:45:00 -0700637 size_t mFrameCount; // output HAL, direct output, record
638 size_t mNormalFrameCount; // normal mixer and effects
Glenn Kasten254af182012-07-03 14:59:05 -0700639 audio_channel_mask_t mChannelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700640 uint16_t mChannelCount;
Glenn Kastenb9980652012-01-11 09:48:27 -0800641 size_t mFrameSize;
Glenn Kasten58f30212012-01-12 12:27:51 -0800642 audio_format_t mFormat;
Glenn Kastencbc52bf2012-03-01 09:21:37 -0800643
644 // Parameter sequence by client: binder thread calling setParameters():
645 // 1. Lock mLock
646 // 2. Append to mNewParameters
647 // 3. mWaitWorkCV.signal
648 // 4. mParamCond.waitRelative with timeout
649 // 5. read mParamStatus
650 // 6. mWaitWorkCV.signal
651 // 7. Unlock
652 //
653 // Parameter sequence by server: threadLoop calling checkForNewParameters_l():
654 // 1. Lock mLock
655 // 2. If there is an entry in mNewParameters proceed ...
656 // 2. Read first entry in mNewParameters
657 // 3. Process
658 // 4. Remove first entry from mNewParameters
659 // 5. Set mParamStatus
660 // 6. mParamCond.signal
661 // 7. mWaitWorkCV.wait with timeout (this is to avoid overwriting mParamStatus)
662 // 8. Unlock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700663 Condition mParamCond;
664 Vector<String8> mNewParameters;
665 status_t mParamStatus;
Glenn Kastencbc52bf2012-03-01 09:21:37 -0800666
Glenn Kastenf3990f22011-12-13 11:50:00 -0800667 Vector<ConfigEvent> mConfigEvents;
Glenn Kasten01542f22012-07-02 12:46:15 -0700668
669 // These fields are written and read by thread itself without lock or barrier,
670 // and read by other threads without lock or barrier via standby() and device().
671 // Because of the absence of a lock or barrier, any other thread that reads
672 // these fields must use the information in isolation, or be prepared to deal
673 // with possibility that it might be inconsistent with other information.
674 bool mStandby; // Whether thread is currently in standby.
675 audio_devices_t mDevice; // output device for PlaybackThread
676 // input + output devices for RecordThread
677
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800678 const audio_io_handle_t mId;
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700679 Vector< sp<EffectChain> > mEffectChains;
Glenn Kasten01542f22012-07-02 12:46:15 -0700680
Glenn Kasten480b4682012-02-28 12:30:08 -0800681 static const int kNameLength = 16; // prctl(PR_SET_NAME) limit
Eric Laurentfeb0db62011-07-22 09:04:31 -0700682 char mName[kNameLength];
683 sp<IPowerManager> mPowerManager;
684 sp<IBinder> mWakeLockToken;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800685 const sp<PMDeathRecipient> mDeathRecipient;
Eric Laurent59255e42011-07-27 19:49:51 -0700686 // list of suspended effects per session and per type. The first vector is
687 // keyed by session ID, the second by type UUID timeLow field
688 KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700689 };
690
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800691 struct stream_type_t {
692 stream_type_t()
693 : volume(1.0f),
Eric Laurent1a9ed112012-03-20 18:36:01 -0700694 mute(false)
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800695 {
696 }
697 float volume;
698 bool mute;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800699 };
700
Mathias Agopian65ab4712010-07-14 17:59:35 -0700701 // --- PlaybackThread ---
702 class PlaybackThread : public ThreadBase {
703 public:
704
Mathias Agopian65ab4712010-07-14 17:59:35 -0700705 enum mixer_state {
Glenn Kastend805b712012-02-24 15:42:48 -0800706 MIXER_IDLE, // no active tracks
707 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
708 MIXER_TRACKS_READY // at least one active track, and at least one track has data
709 // standby mode does not have an enum value
710 // suspend by audio policy manager is orthogonal to mixer state
Mathias Agopian65ab4712010-07-14 17:59:35 -0700711 };
712
713 // playback track
Glenn Kasten58912562012-04-03 10:45:00 -0700714 class Track : public TrackBase, public VolumeProvider {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700715 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800716 Track( PlaybackThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700717 const sp<Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800718 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700719 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800720 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -0700721 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700722 int frameCount,
723 const sp<IMemory>& sharedBuffer,
Glenn Kasten73d22752012-03-19 13:38:30 -0700724 int sessionId,
725 IAudioFlinger::track_flags_t flags);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800726 virtual ~Track();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700727
Glenn Kasten288ed212012-04-25 17:52:27 -0700728 static void appendDumpHeader(String8& result);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700729 void dump(char* buffer, size_t size);
Glenn Kasten3acbd052012-02-28 10:39:56 -0800730 virtual status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
Eric Laurenta011e352012-03-29 15:51:43 -0700731 int triggerSession = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700732 virtual void stop();
733 void pause();
734
735 void flush();
736 void destroy();
737 void mute(bool);
Glenn Kasten9f34a362012-03-20 16:46:41 -0700738 int name() const { return mName; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700739
Glenn Kasten02bbd202012-02-08 12:35:35 -0800740 audio_stream_type_t streamType() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700741 return mStreamType;
742 }
743 status_t attachAuxEffect(int EffectId);
744 void setAuxBuffer(int EffectId, int32_t *buffer);
Glenn Kastenc59c0042012-02-02 14:06:11 -0800745 int32_t *auxBuffer() const { return mAuxBuffer; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700746 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800747 int16_t *mainBuffer() const { return mMainBuffer; }
748 int auxEffectId() const { return mAuxEffectId; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700749
Glenn Kasten58912562012-04-03 10:45:00 -0700750 // implement FastMixerState::VolumeProvider interface
751 virtual uint32_t getVolumeLR();
Eric Laurent29864602012-05-08 18:57:51 -0700752 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
Glenn Kasten73d22752012-03-19 13:38:30 -0700753
Mathias Agopian65ab4712010-07-14 17:59:35 -0700754 protected:
Glenn Kasten19986612012-03-09 12:07:30 -0800755 // for numerous
Mathias Agopian65ab4712010-07-14 17:59:35 -0700756 friend class PlaybackThread;
757 friend class MixerThread;
758 friend class DirectOutputThread;
759
760 Track(const Track&);
761 Track& operator = (const Track&);
762
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800763 // AudioBufferProvider interface
764 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS);
765 // releaseBuffer() not overridden
766
Glenn Kasten288ed212012-04-25 17:52:27 -0700767 virtual size_t framesReady() const;
John Grossman4ff14ba2012-02-08 16:37:41 -0800768
Glenn Kastenc59c0042012-02-02 14:06:11 -0800769 bool isMuted() const { return mMute; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700770 bool isPausing() const {
771 return mState == PAUSING;
772 }
773 bool isPaused() const {
774 return mState == PAUSED;
775 }
Glenn Kasten288ed212012-04-25 17:52:27 -0700776 bool isResuming() const {
777 return mState == RESUMING;
778 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700779 bool isReady() const;
780 void setPaused() { mState = PAUSED; }
781 void reset();
782
783 bool isOutputTrack() const {
Dima Zavinfce7a472011-04-19 22:30:36 -0700784 return (mStreamType == AUDIO_STREAM_CNT);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700785 }
786
Eric Laurent83faee02012-04-27 18:24:29 -0700787 sp<IMemory> sharedBuffer() const { return mSharedBuffer; }
788
Eric Laurenta011e352012-03-29 15:51:43 -0700789 bool presentationComplete(size_t framesWritten, size_t audioHalFrames);
Eric Laurenta011e352012-03-29 15:51:43 -0700790
Glenn Kasten19986612012-03-09 12:07:30 -0800791 public:
Eric Laurent29864602012-05-08 18:57:51 -0700792 void triggerEvents(AudioSystem::sync_event_t type);
John Grossman4ff14ba2012-02-08 16:37:41 -0800793 virtual bool isTimedTrack() const { return false; }
Glenn Kasten58912562012-04-03 10:45:00 -0700794 bool isFastTrack() const { return (mFlags & IAudioFlinger::TRACK_FAST) != 0; }
Glenn Kastena34f8ec2012-06-21 12:57:49 -0700795
Glenn Kasten19986612012-03-09 12:07:30 -0800796 protected:
John Grossman4ff14ba2012-02-08 16:37:41 -0800797
Glenn Kastena34f8ec2012-06-21 12:57:49 -0700798 // written by Track::mute() called by binder thread(s), without a mutex or barrier.
799 // read by Track::isMuted() called by playback thread, also without a mutex or barrier.
800 // The lack of mutex or barrier is safe because the mute status is only used by itself.
801 bool mMute;
802
Mathias Agopian65ab4712010-07-14 17:59:35 -0700803 // FILLED state is used for suppressing volume ramp at begin of playing
Glenn Kasten58912562012-04-03 10:45:00 -0700804 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
Mathias Agopian65ab4712010-07-14 17:59:35 -0700805 mutable uint8_t mFillingUpStatus;
806 int8_t mRetryCount;
Glenn Kastenf9959012012-03-19 11:14:37 -0700807 const sp<IMemory> mSharedBuffer;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700808 bool mResetDone;
Glenn Kastenf9959012012-03-19 11:14:37 -0700809 const audio_stream_type_t mStreamType;
Glenn Kasten288ed212012-04-25 17:52:27 -0700810 int mName; // track name on the normal mixer,
811 // allocated statically at track creation time,
812 // and is even allocated (though unused) for fast tracks
Glenn Kasten893a0542012-05-30 10:32:06 -0700813 // FIXME don't allocate track name for fast tracks
Mathias Agopian65ab4712010-07-14 17:59:35 -0700814 int16_t *mMainBuffer;
815 int32_t *mAuxBuffer;
816 int mAuxEffectId;
Eric Laurent8f45bd72010-08-31 13:50:07 -0700817 bool mHasVolumeController;
Eric Laurenta011e352012-03-29 15:51:43 -0700818 size_t mPresentationCompleteFrames; // number of frames written to the audio HAL
819 // when this track will be fully rendered
Glenn Kasten73d22752012-03-19 13:38:30 -0700820 private:
821 IAudioFlinger::track_flags_t mFlags;
Glenn Kasten288ed212012-04-25 17:52:27 -0700822
823 // The following fields are only for fast tracks, and should be in a subclass
824 int mFastIndex; // index within FastMixerState::mFastTracks[];
Glenn Kasten893a0542012-05-30 10:32:06 -0700825 // either mFastIndex == -1 if not isFastTrack()
Glenn Kasten288ed212012-04-25 17:52:27 -0700826 // or 0 < mFastIndex < FastMixerState::kMaxFast because
827 // index 0 is reserved for normal mixer's submix;
828 // index is allocated statically at track creation time
829 // but the slot is only used if track is active
Glenn Kasten09474df2012-05-10 14:48:07 -0700830 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
Glenn Kasten288ed212012-04-25 17:52:27 -0700831 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
832 uint32_t mUnderrunCount; // Counter of total number of underruns, never reset
Glenn Kasten58912562012-04-03 10:45:00 -0700833 volatile float mCachedVolume; // combined master volume and stream type volume;
834 // 'volatile' means accessed without lock or
835 // barrier, but is read/written atomically
Mathias Agopian65ab4712010-07-14 17:59:35 -0700836 }; // end of Track
837
John Grossman4ff14ba2012-02-08 16:37:41 -0800838 class TimedTrack : public Track {
839 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800840 static sp<TimedTrack> create(PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -0800841 const sp<Client>& client,
842 audio_stream_type_t streamType,
843 uint32_t sampleRate,
844 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -0700845 audio_channel_mask_t channelMask,
John Grossman4ff14ba2012-02-08 16:37:41 -0800846 int frameCount,
847 const sp<IMemory>& sharedBuffer,
848 int sessionId);
Glenn Kastend96c5722012-04-25 13:44:49 -0700849 virtual ~TimedTrack();
John Grossman4ff14ba2012-02-08 16:37:41 -0800850
851 class TimedBuffer {
852 public:
853 TimedBuffer();
854 TimedBuffer(const sp<IMemory>& buffer, int64_t pts);
855 const sp<IMemory>& buffer() const { return mBuffer; }
856 int64_t pts() const { return mPTS; }
John Grossman1c345192012-03-27 14:00:17 -0700857 uint32_t position() const { return mPosition; }
858 void setPosition(uint32_t pos) { mPosition = pos; }
John Grossman4ff14ba2012-02-08 16:37:41 -0800859 private:
860 sp<IMemory> mBuffer;
John Grossman1c345192012-03-27 14:00:17 -0700861 int64_t mPTS;
862 uint32_t mPosition;
John Grossman4ff14ba2012-02-08 16:37:41 -0800863 };
864
John Grossman1c345192012-03-27 14:00:17 -0700865 // Mixer facing methods.
John Grossman4ff14ba2012-02-08 16:37:41 -0800866 virtual bool isTimedTrack() const { return true; }
Glenn Kasten288ed212012-04-25 17:52:27 -0700867 virtual size_t framesReady() const;
John Grossman4ff14ba2012-02-08 16:37:41 -0800868
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800869 // AudioBufferProvider interface
John Grossman1c345192012-03-27 14:00:17 -0700870 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer,
871 int64_t pts);
John Grossman4ff14ba2012-02-08 16:37:41 -0800872 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
John Grossman4ff14ba2012-02-08 16:37:41 -0800873
John Grossman1c345192012-03-27 14:00:17 -0700874 // Client/App facing methods.
John Grossman4ff14ba2012-02-08 16:37:41 -0800875 status_t allocateTimedBuffer(size_t size,
876 sp<IMemory>* buffer);
877 status_t queueTimedBuffer(const sp<IMemory>& buffer,
878 int64_t pts);
879 status_t setMediaTimeTransform(const LinearTransform& xform,
880 TimedAudioTrack::TargetTimeline target);
John Grossman4ff14ba2012-02-08 16:37:41 -0800881
882 private:
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800883 TimedTrack(PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -0800884 const sp<Client>& client,
885 audio_stream_type_t streamType,
886 uint32_t sampleRate,
887 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -0700888 audio_channel_mask_t channelMask,
John Grossman4ff14ba2012-02-08 16:37:41 -0800889 int frameCount,
890 const sp<IMemory>& sharedBuffer,
891 int sessionId);
892
John Grossman1c345192012-03-27 14:00:17 -0700893 void timedYieldSamples_l(AudioBufferProvider::Buffer* buffer);
894 void timedYieldSilence_l(uint32_t numFrames,
895 AudioBufferProvider::Buffer* buffer);
896 void trimTimedBufferQueue_l();
897 void trimTimedBufferQueueHead_l(const char* logTag);
898 void updateFramesPendingAfterTrim_l(const TimedBuffer& buf,
899 const char* logTag);
900
John Grossman4ff14ba2012-02-08 16:37:41 -0800901 uint64_t mLocalTimeFreq;
902 LinearTransform mLocalTimeToSampleTransform;
John Grossman9fbdee12012-03-26 17:51:46 -0700903 LinearTransform mMediaTimeToSampleTransform;
John Grossman4ff14ba2012-02-08 16:37:41 -0800904 sp<MemoryDealer> mTimedMemoryDealer;
John Grossman9fbdee12012-03-26 17:51:46 -0700905
John Grossman4ff14ba2012-02-08 16:37:41 -0800906 Vector<TimedBuffer> mTimedBufferQueue;
John Grossman9fbdee12012-03-26 17:51:46 -0700907 bool mQueueHeadInFlight;
908 bool mTrimQueueHeadOnRelease;
John Grossman1c345192012-03-27 14:00:17 -0700909 uint32_t mFramesPendingInQueue;
John Grossman9fbdee12012-03-26 17:51:46 -0700910
John Grossman4ff14ba2012-02-08 16:37:41 -0800911 uint8_t* mTimedSilenceBuffer;
912 uint32_t mTimedSilenceBufferSize;
913 mutable Mutex mTimedBufferQueueLock;
914 bool mTimedAudioOutputOnTime;
915 CCHelper mCCHelper;
916
917 Mutex mMediaTimeTransformLock;
918 LinearTransform mMediaTimeTransform;
919 bool mMediaTimeTransformValid;
920 TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget;
921 };
922
Mathias Agopian65ab4712010-07-14 17:59:35 -0700923
924 // playback track
925 class OutputTrack : public Track {
926 public:
927
928 class Buffer: public AudioBufferProvider::Buffer {
929 public:
930 int16_t *mBuffer;
931 };
932
Glenn Kasten9eaa5572012-01-20 13:32:16 -0800933 OutputTrack(PlaybackThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700934 DuplicatingThread *sourceThread,
935 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800936 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -0700937 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700938 int frameCount);
Glenn Kastenc19e2242012-01-30 14:54:39 -0800939 virtual ~OutputTrack();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700940
Glenn Kasten3acbd052012-02-28 10:39:56 -0800941 virtual status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
Eric Laurenta011e352012-03-29 15:51:43 -0700942 int triggerSession = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700943 virtual void stop();
944 bool write(int16_t* data, uint32_t frames);
Glenn Kastena1117922012-01-26 10:53:32 -0800945 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800946 bool isActive() const { return mActive; }
947 const wp<ThreadBase>& thread() const { return mThread; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700948
949 private:
950
Glenn Kasten335787f2012-01-20 17:00:00 -0800951 enum {
952 NO_MORE_BUFFERS = 0x80000001, // same in AudioTrack.h, ok to be different value
953 };
954
Mathias Agopian65ab4712010-07-14 17:59:35 -0700955 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs);
956 void clearBufferQueue();
957
958 // Maximum number of pending buffers allocated by OutputTrack::write()
959 static const uint8_t kMaxOverFlowBuffers = 10;
960
961 Vector < Buffer* > mBufferQueue;
962 AudioBufferProvider::Buffer mOutBuffer;
963 bool mActive;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800964 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700965 }; // end of OutputTrack
966
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800967 PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Glenn Kastenbb4350d2012-07-03 15:56:38 -0700968 audio_io_handle_t id, audio_devices_t device, type_t type);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700969 virtual ~PlaybackThread();
970
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700971 void dump(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700972
973 // Thread virtuals
974 virtual status_t readyToRun();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800975 virtual bool threadLoop();
976
977 // RefBase
Mathias Agopian65ab4712010-07-14 17:59:35 -0700978 virtual void onFirstRef();
979
Glenn Kasten000f0e32012-03-01 17:10:56 -0800980protected:
981 // Code snippets that were lifted up out of threadLoop()
982 virtual void threadLoop_mix() = 0;
983 virtual void threadLoop_sleepTime() = 0;
984 virtual void threadLoop_write();
985 virtual void threadLoop_standby();
Eric Laurent44a957f2012-05-15 15:26:05 -0700986 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
Glenn Kasten000f0e32012-03-01 17:10:56 -0800987
Glenn Kasten288ed212012-04-25 17:52:27 -0700988 // prepareTracks_l reads and writes mActiveTracks, and returns
989 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
990 // is responsible for clearing or destroying this Vector later on, when it
Glenn Kasten1465f0c2012-03-06 11:23:32 -0800991 // is safe to do so. That will drop the final ref count and destroy the tracks.
992 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Glenn Kasten000f0e32012-03-01 17:10:56 -0800993
994public:
995
Glenn Kastene0feee32011-12-13 11:53:26 -0800996 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700997
Glenn Kasten688aac72012-03-09 10:30:26 -0800998 // return estimated latency in milliseconds, as reported by HAL
999 uint32_t latency() const;
Marco Nelissenf06c2ed2012-06-06 09:52:31 -07001000 // same, but lock must already be held
1001 uint32_t latency_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001002
Glenn Kasten6637baa2012-01-09 09:40:36 -08001003 void setMasterVolume(float value);
1004 void setMasterMute(bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001005
Glenn Kasten6637baa2012-01-09 09:40:36 -08001006 void setStreamVolume(audio_stream_type_t stream, float value);
1007 void setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001008
Glenn Kasten6637baa2012-01-09 09:40:36 -08001009 float streamVolume(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001010
Mathias Agopian65ab4712010-07-14 17:59:35 -07001011 sp<Track> createTrack_l(
1012 const sp<AudioFlinger::Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -08001013 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001014 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001015 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -07001016 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001017 int frameCount,
1018 const sp<IMemory>& sharedBuffer,
1019 int sessionId,
Glenn Kasten73d22752012-03-19 13:38:30 -07001020 IAudioFlinger::track_flags_t flags,
Glenn Kasten3acbd052012-02-28 10:39:56 -08001021 pid_t tid,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001022 status_t *status);
1023
Glenn Kastenaed850d2012-01-26 09:46:34 -08001024 AudioStreamOut* getOutput() const;
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001025 AudioStreamOut* clearOutput();
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001026 virtual audio_stream_t* stream() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001027
Glenn Kasten1ea6d232012-07-09 14:31:33 -07001028 // a very large number of suspend() will eventually wraparound, but unlikely
1029 void suspend() { (void) android_atomic_inc(&mSuspended); }
1030 void restore()
1031 {
1032 // if restore() is done without suspend(), get back into
1033 // range so that the next suspend() will operate correctly
1034 if (android_atomic_dec(&mSuspended) <= 0) {
1035 android_atomic_release_store(0, &mSuspended);
1036 }
1037 }
1038 bool isSuspended() const
1039 { return android_atomic_acquire_load(&mSuspended) > 0; }
1040
Mathias Agopian65ab4712010-07-14 17:59:35 -07001041 virtual String8 getParameters(const String8& keys);
1042 virtual void audioConfigChanged_l(int event, int param = 0);
Glenn Kasten688aac72012-03-09 10:30:26 -08001043 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Glenn Kastenc59c0042012-02-02 14:06:11 -08001044 int16_t *mixBuffer() const { return mMixBuffer; };
Mathias Agopian65ab4712010-07-14 17:59:35 -07001045
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001046 virtual void detachAuxEffect_l(int effectId);
Eric Laurentde070132010-07-13 04:45:46 -07001047 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track,
1048 int EffectId);
1049 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track,
1050 int EffectId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001051
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001052 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1053 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Glenn Kasten106e8a42012-08-02 13:37:12 -07001054 virtual uint32_t hasAudioSession(int sessionId) const;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001055 virtual uint32_t getStrategyForSession_l(int sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07001056
Eric Laurent9f6530f2011-08-30 10:18:54 -07001057
Eric Laurenta011e352012-03-29 15:51:43 -07001058 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
Glenn Kasten106e8a42012-08-02 13:37:12 -07001059 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Eric Laurent22167852012-06-20 12:26:32 -07001060 void invalidateTracks(audio_stream_type_t streamType);
1061
Eric Laurenta011e352012-03-29 15:51:43 -07001062
Mathias Agopian65ab4712010-07-14 17:59:35 -07001063 protected:
Mathias Agopian65ab4712010-07-14 17:59:35 -07001064 int16_t* mMixBuffer;
Glenn Kasten1ea6d232012-07-09 14:31:33 -07001065
1066 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
1067 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
1068 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
1069 // workaround that restriction.
1070 // 'volatile' means accessed via atomic operations and no lock.
1071 volatile int32_t mSuspended;
1072
Mathias Agopian65ab4712010-07-14 17:59:35 -07001073 int mBytesWritten;
Glenn Kasten98067102011-12-13 11:47:54 -08001074 private:
Glenn Kasten99e53b82012-01-19 08:59:58 -08001075 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
1076 // PlaybackThread needs to find out if master-muted, it checks it's local
1077 // copy rather than the one in AudioFlinger. This optimization saves a lock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001078 bool mMasterMute;
Glenn Kasten6637baa2012-01-09 09:40:36 -08001079 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Glenn Kasten98067102011-12-13 11:47:54 -08001080 protected:
Glenn Kasten288ed212012-04-25 17:52:27 -07001081 SortedVector< wp<Track> > mActiveTracks; // FIXME check if this could be sp<>
Mathias Agopian65ab4712010-07-14 17:59:35 -07001082
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07001083 // Allocate a track name for a given channel mask.
1084 // Returns name >= 0 if successful, -1 on failure.
1085 virtual int getTrackName_l(audio_channel_mask_t channelMask) = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001086 virtual void deleteTrackName_l(int name) = 0;
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001087
1088 // Time to sleep between cycles when:
1089 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
1090 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
1091 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
1092 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
1093 // No sleep in standby mode; waits on a condition
Mathias Agopian65ab4712010-07-14 17:59:35 -07001094
Glenn Kasten37d825e2012-02-24 07:21:48 -08001095 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
1096 void checkSilentMode_l();
1097
Glenn Kastenfa26a852012-03-06 11:28:04 -08001098 // Non-trivial for DUPLICATING only
1099 virtual void saveOutputTracks() { }
1100 virtual void clearOutputTracks() { }
1101
Glenn Kasten66fcab92012-02-24 14:59:21 -08001102 // Cache various calculated values, at threadLoop() entry and after a parameter change
1103 virtual void cacheParameters_l();
1104
Eric Laurente737cda2012-05-22 18:55:44 -07001105 virtual uint32_t correctLatency(uint32_t latency) const;
1106
Mathias Agopian65ab4712010-07-14 17:59:35 -07001107 private:
1108
Glenn Kasten19986612012-03-09 12:07:30 -08001109 friend class AudioFlinger; // for numerous
Mathias Agopian65ab4712010-07-14 17:59:35 -07001110
1111 PlaybackThread(const Client&);
1112 PlaybackThread& operator = (const PlaybackThread&);
1113
1114 status_t addTrack_l(const sp<Track>& track);
1115 void destroyTrack_l(const sp<Track>& track);
Eric Laurentb469b942011-05-09 12:09:06 -07001116 void removeTrack_l(const sp<Track>& track);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001117
1118 void readOutputParameters();
1119
Glenn Kastenbe5f05e2012-07-18 15:24:02 -07001120 virtual void dumpInternals(int fd, const Vector<String16>& args);
1121 void dumpTracks(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001122
1123 SortedVector< sp<Track> > mTracks;
Glenn Kasten263709e2012-01-06 08:40:01 -08001124 // mStreamTypes[] uses 1 additional stream type internally for the OutputTrack used by DuplicatingThread
Dima Zavinfce7a472011-04-19 22:30:36 -07001125 stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1];
Glenn Kastenaed850d2012-01-26 09:46:34 -08001126 AudioStreamOut *mOutput;
Glenn Kasten9f34a362012-03-20 16:46:41 -07001127
Mathias Agopian65ab4712010-07-14 17:59:35 -07001128 float mMasterVolume;
1129 nsecs_t mLastWriteTime;
1130 int mNumWrites;
1131 int mNumDelayedWrites;
1132 bool mInWrite;
Glenn Kasten000f0e32012-03-01 17:10:56 -08001133
1134 // FIXME rename these former local variables of threadLoop to standard "m" names
1135 nsecs_t standbyTime;
1136 size_t mixBufferSize;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001137
1138 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Glenn Kasten000f0e32012-03-01 17:10:56 -08001139 uint32_t activeSleepTime;
1140 uint32_t idleSleepTime;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001141
Glenn Kasten000f0e32012-03-01 17:10:56 -08001142 uint32_t sleepTime;
Glenn Kastenfec279f2012-03-08 07:47:15 -08001143
1144 // mixer status returned by prepareTracks_l()
Eric Laurentda747442012-04-25 18:53:13 -07001145 mixer_state mMixerStatus; // current cycle
1146 // previous cycle when in prepareTracks_l()
Glenn Kasten81028042012-04-30 18:15:12 -07001147 mixer_state mMixerStatusIgnoringFastTracks;
1148 // FIXME or a separate ready state per track
Glenn Kasten000f0e32012-03-01 17:10:56 -08001149
1150 // FIXME move these declarations into the specific sub-class that needs them
1151 // MIXER only
Glenn Kasten000f0e32012-03-01 17:10:56 -08001152 uint32_t sleepTimeShift;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001153
1154 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Glenn Kasten000f0e32012-03-01 17:10:56 -08001155 nsecs_t standbyDelay;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001156
1157 // MIXER only
1158 nsecs_t maxPeriod;
1159
Glenn Kasten000f0e32012-03-01 17:10:56 -08001160 // DUPLICATING only
Glenn Kasten000f0e32012-03-01 17:10:56 -08001161 uint32_t writeFrames;
Glenn Kasten58912562012-04-03 10:45:00 -07001162
1163 private:
1164 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1165 sp<NBAIO_Sink> mOutputSink;
1166 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1167 sp<NBAIO_Sink> mPipeSink;
1168 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1169 sp<NBAIO_Sink> mNormalSink;
Glenn Kastenfbae5da2012-05-21 09:17:20 -07001170 // For dumpsys
1171 sp<NBAIO_Sink> mTeeSink;
1172 sp<NBAIO_Source> mTeeSource;
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001173 uint32_t mScreenState; // cached copy of gScreenState
Glenn Kasten58912562012-04-03 10:45:00 -07001174 public:
1175 virtual bool hasFastMixer() const = 0;
Glenn Kasten09474df2012-05-10 14:48:07 -07001176 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const
1177 { FastTrackUnderruns dummy; return dummy; }
Glenn Kasten58912562012-04-03 10:45:00 -07001178
1179 protected:
1180 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1181 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Glenn Kasten58912562012-04-03 10:45:00 -07001182
Mathias Agopian65ab4712010-07-14 17:59:35 -07001183 };
1184
1185 class MixerThread : public PlaybackThread {
1186 public:
Eric Laurentde070132010-07-13 04:45:46 -07001187 MixerThread (const sp<AudioFlinger>& audioFlinger,
Dima Zavin799a70e2011-04-18 16:57:27 -07001188 AudioStreamOut* output,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001189 audio_io_handle_t id,
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001190 audio_devices_t device,
Glenn Kasten23bb8be2012-01-26 10:38:26 -08001191 type_t type = MIXER);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192 virtual ~MixerThread();
1193
1194 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -07001195
Mathias Agopian65ab4712010-07-14 17:59:35 -07001196 virtual bool checkForNewParameters_l();
Glenn Kastenbe5f05e2012-07-18 15:24:02 -07001197 virtual void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001198
1199 protected:
Glenn Kasten000f0e32012-03-01 17:10:56 -08001200 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07001201 virtual int getTrackName_l(audio_channel_mask_t channelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001202 virtual void deleteTrackName_l(int name);
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001203 virtual uint32_t idleSleepTimeUs() const;
1204 virtual uint32_t suspendSleepTimeUs() const;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001205 virtual void cacheParameters_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001206
Glenn Kasten000f0e32012-03-01 17:10:56 -08001207 // threadLoop snippets
Glenn Kasten58912562012-04-03 10:45:00 -07001208 virtual void threadLoop_write();
1209 virtual void threadLoop_standby();
Glenn Kasten000f0e32012-03-01 17:10:56 -08001210 virtual void threadLoop_mix();
1211 virtual void threadLoop_sleepTime();
Glenn Kasten58912562012-04-03 10:45:00 -07001212 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
Eric Laurente737cda2012-05-22 18:55:44 -07001213 virtual uint32_t correctLatency(uint32_t latency) const;
Glenn Kasten000f0e32012-03-01 17:10:56 -08001214
Glenn Kasten58912562012-04-03 10:45:00 -07001215 AudioMixer* mAudioMixer; // normal mixer
1216 private:
Glenn Kasten58912562012-04-03 10:45:00 -07001217 // one-time initialization, no locks required
1218 FastMixer* mFastMixer; // non-NULL if there is also a fast mixer
Glenn Kastenc15d6652012-05-30 14:52:57 -07001219 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
Glenn Kasten58912562012-04-03 10:45:00 -07001220
1221 // contents are not guaranteed to be consistent, no locks required
1222 FastMixerDumpState mFastMixerDumpState;
Glenn Kasten39993082012-05-31 13:40:27 -07001223#ifdef STATE_QUEUE_DUMP
1224 StateQueueObserverDump mStateQueueObserverDump;
1225 StateQueueMutatorDump mStateQueueMutatorDump;
1226#endif
Glenn Kastenc15d6652012-05-30 14:52:57 -07001227 AudioWatchdogDump mAudioWatchdogDump;
Glenn Kasten58912562012-04-03 10:45:00 -07001228
1229 // accessible only within the threadLoop(), no locks required
1230 // mFastMixer->sq() // for mutating and pushing state
1231 int32_t mFastMixerFutex; // for cold idle
1232
1233 public:
1234 virtual bool hasFastMixer() const { return mFastMixer != NULL; }
Glenn Kasten09474df2012-05-10 14:48:07 -07001235 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kasten88cbea82012-05-15 07:39:27 -07001236 ALOG_ASSERT(fastIndex < FastMixerState::kMaxFastTracks);
Glenn Kasten09474df2012-05-10 14:48:07 -07001237 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
Glenn Kasten288ed212012-04-25 17:52:27 -07001238 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001239 };
1240
1241 class DirectOutputThread : public PlaybackThread {
1242 public:
1243
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001244 DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001245 audio_io_handle_t id, audio_devices_t device);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001246 virtual ~DirectOutputThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001247
1248 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -07001249
1250 virtual bool checkForNewParameters_l();
1251
1252 protected:
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07001253 virtual int getTrackName_l(audio_channel_mask_t channelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001254 virtual void deleteTrackName_l(int name);
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001255 virtual uint32_t activeSleepTimeUs() const;
1256 virtual uint32_t idleSleepTimeUs() const;
1257 virtual uint32_t suspendSleepTimeUs() const;
Glenn Kasten66fcab92012-02-24 14:59:21 -08001258 virtual void cacheParameters_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001259
Glenn Kasten000f0e32012-03-01 17:10:56 -08001260 // threadLoop snippets
Glenn Kasten1465f0c2012-03-06 11:23:32 -08001261 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Glenn Kasten000f0e32012-03-01 17:10:56 -08001262 virtual void threadLoop_mix();
1263 virtual void threadLoop_sleepTime();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001264
Glenn Kasten99e53b82012-01-19 08:59:58 -08001265 // volumes last sent to audio HAL with stream->set_volume()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001266 float mLeftVolFloat;
1267 float mRightVolFloat;
Glenn Kastend4513b02012-03-06 15:52:35 -08001268
1269private:
Glenn Kastenb071e9b2012-03-07 17:05:59 -08001270 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1271 sp<Track> mActiveTrack;
Glenn Kasten58912562012-04-03 10:45:00 -07001272 public:
1273 virtual bool hasFastMixer() const { return false; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001274 };
1275
1276 class DuplicatingThread : public MixerThread {
1277 public:
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001278 DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
1279 audio_io_handle_t id);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001280 virtual ~DuplicatingThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001281
1282 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -07001283 void addOutputTrack(MixerThread* thread);
1284 void removeOutputTrack(MixerThread* thread);
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001285 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001286 protected:
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001287 virtual uint32_t activeSleepTimeUs() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001288
1289 private:
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001290 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
Glenn Kasten000f0e32012-03-01 17:10:56 -08001291 protected:
1292 // threadLoop snippets
1293 virtual void threadLoop_mix();
1294 virtual void threadLoop_sleepTime();
1295 virtual void threadLoop_write();
1296 virtual void threadLoop_standby();
Glenn Kasten66fcab92012-02-24 14:59:21 -08001297 virtual void cacheParameters_l();
Glenn Kasten438b0362012-03-06 11:24:48 -08001298
Glenn Kasten66fcab92012-02-24 14:59:21 -08001299 private:
Glenn Kasten438b0362012-03-06 11:24:48 -08001300 // called from threadLoop, addOutputTrack, removeOutputTrack
1301 virtual void updateWaitTime_l();
Glenn Kasten66fcab92012-02-24 14:59:21 -08001302 protected:
Glenn Kastenfa26a852012-03-06 11:28:04 -08001303 virtual void saveOutputTracks();
1304 virtual void clearOutputTracks();
Glenn Kasten000f0e32012-03-01 17:10:56 -08001305 private:
Mathias Agopian65ab4712010-07-14 17:59:35 -07001306
Mathias Agopian65ab4712010-07-14 17:59:35 -07001307 uint32_t mWaitTimeMs;
Glenn Kastenfa26a852012-03-06 11:28:04 -08001308 SortedVector < sp<OutputTrack> > outputTracks;
1309 SortedVector < sp<OutputTrack> > mOutputTracks;
Glenn Kasten58912562012-04-03 10:45:00 -07001310 public:
1311 virtual bool hasFastMixer() const { return false; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001312 };
1313
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001314 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
1315 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
1316 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Glenn Kasten6637baa2012-01-09 09:40:36 -08001317 // no range check, AudioFlinger::mLock held
1318 bool streamMute_l(audio_stream_type_t stream) const
1319 { return mStreamTypes[stream].mute; }
1320 // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
1321 float streamVolume_l(audio_stream_type_t stream) const
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001322 { return mStreamTypes[stream].volume; }
Glenn Kastenb81cc8c2012-03-01 09:14:51 -08001323 void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001324
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001325 // allocate an audio_io_handle_t, session ID, or effect ID
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001326 uint32_t nextUniqueId();
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001327
Eric Laurent59255e42011-07-27 19:49:51 -07001328 status_t moveEffectChain_l(int sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -08001329 PlaybackThread *srcThread,
1330 PlaybackThread *dstThread,
Eric Laurent39e94f82010-07-28 01:32:47 -07001331 bool reRegister);
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08001332 // return thread associated with primary hardware device, or NULL
1333 PlaybackThread *primaryPlaybackThread_l() const;
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001334 audio_devices_t primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001335
Eric Laurent717e1282012-06-29 16:36:52 -07001336 sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId);
1337
Glenn Kasten99e53b82012-01-19 08:59:58 -08001338 // server side of the client's IAudioTrack
Mathias Agopian65ab4712010-07-14 17:59:35 -07001339 class TrackHandle : public android::BnAudioTrack {
1340 public:
1341 TrackHandle(const sp<PlaybackThread::Track>& track);
1342 virtual ~TrackHandle();
Glenn Kasten90716c52012-01-26 13:40:12 -08001343 virtual sp<IMemory> getCblk() const;
Glenn Kasten3acbd052012-02-28 10:39:56 -08001344 virtual status_t start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001345 virtual void stop();
1346 virtual void flush();
1347 virtual void mute(bool);
1348 virtual void pause();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001349 virtual status_t attachAuxEffect(int effectId);
John Grossman4ff14ba2012-02-08 16:37:41 -08001350 virtual status_t allocateTimedBuffer(size_t size,
1351 sp<IMemory>* buffer);
1352 virtual status_t queueTimedBuffer(const sp<IMemory>& buffer,
1353 int64_t pts);
1354 virtual status_t setMediaTimeTransform(const LinearTransform& xform,
1355 int target);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001356 virtual status_t onTransact(
1357 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
1358 private:
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001359 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001360 };
1361
Mathias Agopian65ab4712010-07-14 17:59:35 -07001362 void removeClient_l(pid_t pid);
1363 void removeNotificationClient(pid_t pid);
1364
1365
1366 // record thread
1367 class RecordThread : public ThreadBase, public AudioBufferProvider
Glenn Kastenc3ae93f2012-07-30 10:59:30 -07001368 // derives from AudioBufferProvider interface for use by resampler
Mathias Agopian65ab4712010-07-14 17:59:35 -07001369 {
1370 public:
1371
1372 // record track
1373 class RecordTrack : public TrackBase {
1374 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001375 RecordTrack(RecordThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001376 const sp<Client>& client,
1377 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001378 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -07001379 audio_channel_mask_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001380 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001381 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001382 virtual ~RecordTrack();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001383
Glenn Kasten0ec23ce2012-07-10 12:56:08 -07001384 virtual status_t start(AudioSystem::sync_event_t event, int triggerSession);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001385 virtual void stop();
1386
Glenn Kasten510a3d62012-07-16 14:24:34 -07001387 void destroy();
1388
Glenn Kasten04270da2012-07-10 12:55:49 -07001389 // clear the buffer overflow flag
1390 void clearOverflow() { mOverflow = false; }
1391 // set the buffer overflow flag and return previous value
Mathias Agopian65ab4712010-07-14 17:59:35 -07001392 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
1393
Glenn Kasten510a3d62012-07-16 14:24:34 -07001394 static void appendDumpHeader(String8& result);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001395 void dump(char* buffer, size_t size);
Eric Laurent59255e42011-07-27 19:49:51 -07001396
Mathias Agopian65ab4712010-07-14 17:59:35 -07001397 private:
Glenn Kasten19986612012-03-09 12:07:30 -08001398 friend class AudioFlinger; // for mState
Mathias Agopian65ab4712010-07-14 17:59:35 -07001399
1400 RecordTrack(const RecordTrack&);
1401 RecordTrack& operator = (const RecordTrack&);
1402
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001403 // AudioBufferProvider interface
1404 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS);
1405 // releaseBuffer() not overridden
Mathias Agopian65ab4712010-07-14 17:59:35 -07001406
Glenn Kasten04270da2012-07-10 12:55:49 -07001407 bool mOverflow; // overflow on most recent attempt to fill client buffer
Mathias Agopian65ab4712010-07-14 17:59:35 -07001408 };
1409
Mathias Agopian65ab4712010-07-14 17:59:35 -07001410 RecordThread(const sp<AudioFlinger>& audioFlinger,
Dima Zavin799a70e2011-04-18 16:57:27 -07001411 AudioStreamIn *input,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001412 uint32_t sampleRate,
Glenn Kasten254af182012-07-03 14:59:05 -07001413 audio_channel_mask_t channelMask,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001414 audio_io_handle_t id,
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001415 audio_devices_t device);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001416 virtual ~RecordThread();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001417
Glenn Kasten510a3d62012-07-16 14:24:34 -07001418 // no addTrack_l ?
1419 void destroyTrack_l(const sp<RecordTrack>& track);
1420 void removeTrack_l(const sp<RecordTrack>& track);
1421
1422 void dumpInternals(int fd, const Vector<String16>& args);
1423 void dumpTracks(int fd, const Vector<String16>& args);
1424
Glenn Kastenc3ae93f2012-07-30 10:59:30 -07001425 // Thread virtuals
Mathias Agopian65ab4712010-07-14 17:59:35 -07001426 virtual bool threadLoop();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001427 virtual status_t readyToRun();
Glenn Kasten000f0e32012-03-01 17:10:56 -08001428
1429 // RefBase
Mathias Agopian65ab4712010-07-14 17:59:35 -07001430 virtual void onFirstRef();
1431
Glenn Kastene0feee32011-12-13 11:53:26 -08001432 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001433 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1434 const sp<AudioFlinger::Client>& client,
1435 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001436 audio_format_t format,
Glenn Kasten254af182012-07-03 14:59:05 -07001437 audio_channel_mask_t channelMask,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001438 int frameCount,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001439 int sessionId,
Glenn Kasten1879fff2012-07-11 15:36:59 -07001440 IAudioFlinger::track_flags_t flags,
1441 pid_t tid,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001442 status_t *status);
1443
Glenn Kasten3acbd052012-02-28 10:39:56 -08001444 status_t start(RecordTrack* recordTrack,
Eric Laurenta011e352012-03-29 15:51:43 -07001445 AudioSystem::sync_event_t event,
1446 int triggerSession);
Glenn Kasten1d491ff2012-07-16 14:28:13 -07001447
1448 // ask the thread to stop the specified track, and
1449 // return true if the caller should then do it's part of the stopping process
1450 bool stop_l(RecordTrack* recordTrack);
1451
Glenn Kastenbe5f05e2012-07-18 15:24:02 -07001452 void dump(int fd, const Vector<String16>& args);
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001453 AudioStreamIn* clearInput();
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08001454 virtual audio_stream_t* stream() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001455
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001456 // AudioBufferProvider interface
1457 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001458 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08001459
Mathias Agopian65ab4712010-07-14 17:59:35 -07001460 virtual bool checkForNewParameters_l();
1461 virtual String8 getParameters(const String8& keys);
1462 virtual void audioConfigChanged_l(int event, int param = 0);
1463 void readInputParameters();
1464 virtual unsigned int getInputFramesLost();
1465
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001466 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1467 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Glenn Kasten106e8a42012-08-02 13:37:12 -07001468 virtual uint32_t hasAudioSession(int sessionId) const;
Glenn Kasten510a3d62012-07-16 14:24:34 -07001469
1470 // Return the set of unique session IDs across all tracks.
1471 // The keys are the session IDs, and the associated values are meaningless.
1472 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kasten106e8a42012-08-02 13:37:12 -07001473 KeyedVector<int, bool> sessionIds() const;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001474
Eric Laurenta011e352012-03-29 15:51:43 -07001475 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
Glenn Kasten106e8a42012-08-02 13:37:12 -07001476 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Eric Laurenta011e352012-03-29 15:51:43 -07001477
1478 static void syncStartEventCallback(const wp<SyncEvent>& event);
1479 void handleSyncStartEvent(const sp<SyncEvent>& event);
1480
Mathias Agopian65ab4712010-07-14 17:59:35 -07001481 private:
Eric Laurenta011e352012-03-29 15:51:43 -07001482 void clearSyncStartEvent();
1483
Glenn Kastene4e2a372012-07-23 12:55:09 -07001484 // Enter standby if not already in standby, and set mStandby flag
1485 void standby();
1486
1487 // Call the HAL standby method unconditionally, and don't change mStandby flag
1488 void inputStandBy();
1489
Dima Zavin799a70e2011-04-18 16:57:27 -07001490 AudioStreamIn *mInput;
Glenn Kasten510a3d62012-07-16 14:24:34 -07001491 SortedVector < sp<RecordTrack> > mTracks;
1492 // mActiveTrack has dual roles: it indicates the current active track, and
1493 // is used together with mStartStopCond to indicate start()/stop() progress
Mathias Agopian65ab4712010-07-14 17:59:35 -07001494 sp<RecordTrack> mActiveTrack;
1495 Condition mStartStopCond;
1496 AudioResampler *mResampler;
1497 int32_t *mRsmpOutBuffer;
1498 int16_t *mRsmpInBuffer;
1499 size_t mRsmpInIndex;
1500 size_t mInputBytes;
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001501 const int mReqChannelCount;
1502 const uint32_t mReqSampleRate;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001503 ssize_t mBytesRead;
Eric Laurenta011e352012-03-29 15:51:43 -07001504 // sync event triggering actual audio capture. Frames read before this event will
1505 // be dropped and therefore not read by the application.
1506 sp<SyncEvent> mSyncStartEvent;
1507 // number of captured frames to drop after the start sync event has been received.
Eric Laurent29864602012-05-08 18:57:51 -07001508 // when < 0, maximum frames to drop before starting capture even if sync event is
1509 // not received
Eric Laurenta011e352012-03-29 15:51:43 -07001510 ssize_t mFramestoDrop;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001511 };
1512
Glenn Kasten99e53b82012-01-19 08:59:58 -08001513 // server side of the client's IAudioRecord
Mathias Agopian65ab4712010-07-14 17:59:35 -07001514 class RecordHandle : public android::BnAudioRecord {
1515 public:
1516 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
1517 virtual ~RecordHandle();
Glenn Kasten90716c52012-01-26 13:40:12 -08001518 virtual sp<IMemory> getCblk() const;
Glenn Kasten0ec23ce2012-07-10 12:56:08 -07001519 virtual status_t start(int /*AudioSystem::sync_event_t*/ event, int triggerSession);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001520 virtual void stop();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001521 virtual status_t onTransact(
1522 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
1523 private:
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001524 const sp<RecordThread::RecordTrack> mRecordTrack;
Glenn Kastend96c5722012-04-25 13:44:49 -07001525
1526 // for use from destructor
1527 void stop_nonvirtual();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001528 };
1529
1530 //--- Audio Effect Management
1531
1532 // EffectModule and EffectChain classes both have their own mutex to protect
1533 // state changes or resource modifications. Always respect the following order
1534 // if multiple mutexes must be acquired to avoid cross deadlock:
1535 // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule
1536
1537 // The EffectModule class is a wrapper object controlling the effect engine implementation
1538 // in the effect library. It prevents concurrent calls to process() and command() functions
1539 // from different client threads. It keeps a list of EffectHandle objects corresponding
1540 // to all client applications using this effect and notifies applications of effect state,
1541 // control or parameter changes. It manages the activation state machine to send appropriate
1542 // reset, enable, disable commands to effect engine and provide volume
1543 // ramping when effects are activated/deactivated.
1544 // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by
1545 // the attached track(s) to accumulate their auxiliary channel.
1546 class EffectModule: public RefBase {
1547 public:
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001548 EffectModule(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001549 const wp<AudioFlinger::EffectChain>& chain,
1550 effect_descriptor_t *desc,
1551 int id,
1552 int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001553 virtual ~EffectModule();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001554
1555 enum effect_state {
1556 IDLE,
1557 RESTART,
1558 STARTING,
1559 ACTIVE,
1560 STOPPING,
Eric Laurentec437d82011-07-26 20:54:46 -07001561 STOPPED,
1562 DESTROYED
Mathias Agopian65ab4712010-07-14 17:59:35 -07001563 };
1564
Glenn Kastenc59c0042012-02-02 14:06:11 -08001565 int id() const { return mId; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001566 void process();
1567 void updateState();
Eric Laurent25f43952010-07-28 05:40:18 -07001568 status_t command(uint32_t cmdCode,
1569 uint32_t cmdSize,
1570 void *pCmdData,
1571 uint32_t *replySize,
1572 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001573
1574 void reset_l();
1575 status_t configure();
1576 status_t init();
Glenn Kasten28243dd2012-01-26 13:43:46 -08001577 effect_state state() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001578 return mState;
1579 }
1580 uint32_t status() {
1581 return mStatus;
1582 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001583 int sessionId() const {
Eric Laurentde070132010-07-13 04:45:46 -07001584 return mSessionId;
1585 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001586 status_t setEnabled(bool enabled);
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001587 status_t setEnabled_l(bool enabled);
Glenn Kastenc59c0042012-02-02 14:06:11 -08001588 bool isEnabled() const;
1589 bool isProcessEnabled() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001590
1591 void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; }
1592 int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; }
1593 void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; }
1594 int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; }
Eric Laurentde070132010-07-13 04:45:46 -07001595 void setChain(const wp<EffectChain>& chain) { mChain = chain; }
1596 void setThread(const wp<ThreadBase>& thread) { mThread = thread; }
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001597 const wp<ThreadBase>& thread() { return mThread; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001598
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001599 status_t addHandle(EffectHandle *handle);
1600 size_t disconnect(EffectHandle *handle, bool unpinIfLast);
1601 size_t removeHandle(EffectHandle *handle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001602
Glenn Kasten58e5aa32012-06-20 14:08:14 -07001603 const effect_descriptor_t& desc() const { return mDescriptor; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001604 wp<EffectChain>& chain() { return mChain; }
1605
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001606 status_t setDevice(audio_devices_t device);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001607 status_t setVolume(uint32_t *left, uint32_t *right, bool controller);
Glenn Kastenf78aee72012-01-04 11:00:47 -08001608 status_t setMode(audio_mode_t mode);
Eric Laurentec35a142011-10-05 17:42:25 -07001609 status_t start();
Eric Laurentec437d82011-07-26 20:54:46 -07001610 status_t stop();
Eric Laurent59255e42011-07-27 19:49:51 -07001611 void setSuspended(bool suspended);
Glenn Kastena3a85482012-01-04 11:01:11 -08001612 bool suspended() const;
Eric Laurent59255e42011-07-27 19:49:51 -07001613
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001614 EffectHandle* controlHandle_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001615
Glenn Kastenc59c0042012-02-02 14:06:11 -08001616 bool isPinned() const { return mPinned; }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001617 void unPin() { mPinned = false; }
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001618 bool purgeHandles();
1619 void lock() { mLock.lock(); }
1620 void unlock() { mLock.unlock(); }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001621
Glenn Kastenbe5f05e2012-07-18 15:24:02 -07001622 void dump(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001623
1624 protected:
Glenn Kasten19986612012-03-09 12:07:30 -08001625 friend class AudioFlinger; // for mHandles
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001626 bool mPinned;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001627
1628 // Maximum time allocated to effect engines to complete the turn off sequence
1629 static const uint32_t MAX_DISABLE_TIME_MS = 10000;
1630
1631 EffectModule(const EffectModule&);
1632 EffectModule& operator = (const EffectModule&);
1633
1634 status_t start_l();
1635 status_t stop_l();
1636
Glenn Kastena3a85482012-01-04 11:01:11 -08001637mutable Mutex mLock; // mutex for process, commands and handles list protection
Mathias Agopian65ab4712010-07-14 17:59:35 -07001638 wp<ThreadBase> mThread; // parent thread
1639 wp<EffectChain> mChain; // parent effect chain
Glenn Kasten415fa752012-07-02 16:11:18 -07001640 const int mId; // this instance unique ID
1641 const int mSessionId; // audio session ID
Glenn Kasten58e5aa32012-06-20 14:08:14 -07001642 const effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
Mathias Agopian65ab4712010-07-14 17:59:35 -07001643 effect_config_t mConfig; // input and output audio configuration
Eric Laurente1315cf2011-05-17 19:16:02 -07001644 effect_handle_t mEffectInterface; // Effect module C API
Glenn Kasten28243dd2012-01-26 13:43:46 -08001645 status_t mStatus; // initialization status
1646 effect_state mState; // current activation state
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001647 Vector<EffectHandle *> mHandles; // list of client handles
Glenn Kasten99e53b82012-01-19 08:59:58 -08001648 // First handle in mHandles has highest priority and controls the effect module
Mathias Agopian65ab4712010-07-14 17:59:35 -07001649 uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after
1650 // sending disable command.
1651 uint32_t mDisableWaitCnt; // current process() calls count during disable period.
Eric Laurent59255e42011-07-27 19:49:51 -07001652 bool mSuspended; // effect is suspended: temporarily disabled by framework
Mathias Agopian65ab4712010-07-14 17:59:35 -07001653 };
1654
1655 // The EffectHandle class implements the IEffect interface. It provides resources
1656 // to receive parameter updates, keeps track of effect control
1657 // ownership and state and has a pointer to the EffectModule object it is controlling.
1658 // There is one EffectHandle object for each application controlling (or using)
1659 // an effect module.
1660 // The EffectHandle is obtained by calling AudioFlinger::createEffect().
1661 class EffectHandle: public android::BnEffect {
1662 public:
1663
1664 EffectHandle(const sp<EffectModule>& effect,
1665 const sp<AudioFlinger::Client>& client,
1666 const sp<IEffectClient>& effectClient,
1667 int32_t priority);
1668 virtual ~EffectHandle();
1669
1670 // IEffect
1671 virtual status_t enable();
1672 virtual status_t disable();
Eric Laurent25f43952010-07-28 05:40:18 -07001673 virtual status_t command(uint32_t cmdCode,
1674 uint32_t cmdSize,
1675 void *pCmdData,
1676 uint32_t *replySize,
1677 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001678 virtual void disconnect();
Glenn Kasten58123c32012-02-03 10:32:24 -08001679 private:
1680 void disconnect(bool unpinIfLast);
1681 public:
Glenn Kastenc59c0042012-02-02 14:06:11 -08001682 virtual sp<IMemory> getCblk() const { return mCblkMemory; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001683 virtual status_t onTransact(uint32_t code, const Parcel& data,
1684 Parcel* reply, uint32_t flags);
1685
1686
1687 // Give or take control of effect module
Eric Laurent59255e42011-07-27 19:49:51 -07001688 // - hasControl: true if control is given, false if removed
1689 // - signal: true client app should be signaled of change, false otherwise
1690 // - enabled: state of the effect when control is passed
1691 void setControl(bool hasControl, bool signal, bool enabled);
Eric Laurent25f43952010-07-28 05:40:18 -07001692 void commandExecuted(uint32_t cmdCode,
1693 uint32_t cmdSize,
1694 void *pCmdData,
1695 uint32_t replySize,
1696 void *pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001697 void setEnabled(bool enabled);
Glenn Kastenc59c0042012-02-02 14:06:11 -08001698 bool enabled() const { return mEnabled; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001699
1700 // Getters
Glenn Kastenc59c0042012-02-02 14:06:11 -08001701 int id() const { return mEffect->id(); }
1702 int priority() const { return mPriority; }
1703 bool hasControl() const { return mHasControl; }
1704 sp<EffectModule> effect() const { return mEffect; }
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001705 // destroyed_l() must be called with the associated EffectModule mLock held
1706 bool destroyed_l() const { return mDestroyed; }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001707
1708 void dump(char* buffer, size_t size);
1709
1710 protected:
Glenn Kasten19986612012-03-09 12:07:30 -08001711 friend class AudioFlinger; // for mEffect, mHasControl, mEnabled
Mathias Agopian65ab4712010-07-14 17:59:35 -07001712 EffectHandle(const EffectHandle&);
1713 EffectHandle& operator =(const EffectHandle&);
1714
1715 sp<EffectModule> mEffect; // pointer to controlled EffectModule
1716 sp<IEffectClient> mEffectClient; // callback interface for client notifications
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001717 /*const*/ sp<Client> mClient; // client for shared memory allocation, see disconnect()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001718 sp<IMemory> mCblkMemory; // shared memory for control block
1719 effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory
1720 uint8_t* mBuffer; // pointer to parameter area in shared memory
1721 int mPriority; // client application priority to control the effect
1722 bool mHasControl; // true if this handle is controlling the effect
Eric Laurent59255e42011-07-27 19:49:51 -07001723 bool mEnabled; // cached enable state: needed when the effect is
1724 // restored after being suspended
Eric Laurenta5f44eb2012-06-25 11:38:29 -07001725 bool mDestroyed; // Set to true by destructor. Access with EffectModule
1726 // mLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07001727 };
1728
1729 // the EffectChain class represents a group of effects associated to one audio session.
1730 // There can be any number of EffectChain objects per output mixer thread (PlaybackThread).
1731 // The EffecChain with session ID 0 contains global effects applied to the output mix.
1732 // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks)
1733 // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding
1734 // in the effect process order. When attached to a track (session ID != 0), it also provide it's own
1735 // input buffer used by the track as accumulation buffer.
1736 class EffectChain: public RefBase {
1737 public:
1738 EffectChain(const wp<ThreadBase>& wThread, int sessionId);
Glenn Kasten9eaa5572012-01-20 13:32:16 -08001739 EffectChain(ThreadBase *thread, int sessionId);
Glenn Kastenc19e2242012-01-30 14:54:39 -08001740 virtual ~EffectChain();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001741
Eric Laurent59255e42011-07-27 19:49:51 -07001742 // special key used for an entry in mSuspendedEffects keyed vector
1743 // corresponding to a suspend all request.
1744 static const int kKeyForSuspendAll = 0;
1745
Eric Laurent544fe9b2011-11-11 15:42:52 -08001746 // minimum duration during which we force calling effect process when last track on
1747 // a session is stopped or removed to allow effect tail to be rendered
1748 static const int kProcessTailDurationMs = 1000;
1749
Mathias Agopian65ab4712010-07-14 17:59:35 -07001750 void process_l();
1751
1752 void lock() {
1753 mLock.lock();
1754 }
1755 void unlock() {
1756 mLock.unlock();
1757 }
1758
Eric Laurentde070132010-07-13 04:45:46 -07001759 status_t addEffect_l(const sp<EffectModule>& handle);
Eric Laurentcab11242010-07-15 12:50:15 -07001760 size_t removeEffect_l(const sp<EffectModule>& handle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001761
Glenn Kastenc59c0042012-02-02 14:06:11 -08001762 int sessionId() const { return mSessionId; }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001763 void setSessionId(int sessionId) { mSessionId = sessionId; }
Eric Laurentde070132010-07-13 04:45:46 -07001764
Eric Laurentcab11242010-07-15 12:50:15 -07001765 sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor);
1766 sp<EffectModule> getEffectFromId_l(int id);
Eric Laurent59255e42011-07-27 19:49:51 -07001767 sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type);
Eric Laurentcab11242010-07-15 12:50:15 -07001768 bool setVolume_l(uint32_t *left, uint32_t *right);
Glenn Kastenbb4350d2012-07-03 15:56:38 -07001769 void setDevice_l(audio_devices_t device);
Glenn Kastenf78aee72012-01-04 11:00:47 -08001770 void setMode_l(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001771
Mathias Agopian65ab4712010-07-14 17:59:35 -07001772 void setInBuffer(int16_t *buffer, bool ownsBuffer = false) {
1773 mInBuffer = buffer;
1774 mOwnInBuffer = ownsBuffer;
1775 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001776 int16_t *inBuffer() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001777 return mInBuffer;
1778 }
1779 void setOutBuffer(int16_t *buffer) {
1780 mOutBuffer = buffer;
1781 }
Glenn Kastenc59c0042012-02-02 14:06:11 -08001782 int16_t *outBuffer() const {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001783 return mOutBuffer;
1784 }
1785
Eric Laurentb469b942011-05-09 12:09:06 -07001786 void incTrackCnt() { android_atomic_inc(&mTrackCnt); }
1787 void decTrackCnt() { android_atomic_dec(&mTrackCnt); }
Glenn Kasten2df8f552012-07-09 16:46:23 -07001788 int32_t trackCnt() const { return android_atomic_acquire_load(&mTrackCnt); }
Eric Laurentb469b942011-05-09 12:09:06 -07001789
Eric Laurent544fe9b2011-11-11 15:42:52 -08001790 void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt);
1791 mTailBufferCount = mMaxTailBuffers; }
Eric Laurentb469b942011-05-09 12:09:06 -07001792 void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
Glenn Kasten2df8f552012-07-09 16:46:23 -07001793 int32_t activeTrackCnt() const { return android_atomic_acquire_load(&mActiveTrackCnt); }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001794
Glenn Kastenc59c0042012-02-02 14:06:11 -08001795 uint32_t strategy() const { return mStrategy; }
Eric Laurentde070132010-07-13 04:45:46 -07001796 void setStrategy(uint32_t strategy)
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001797 { mStrategy = strategy; }
Eric Laurentde070132010-07-13 04:45:46 -07001798
Eric Laurent59255e42011-07-27 19:49:51 -07001799 // suspend effect of the given type
1800 void setEffectSuspended_l(const effect_uuid_t *type,
1801 bool suspend);
1802 // suspend all eligible effects
1803 void setEffectSuspendedAll_l(bool suspend);
1804 // check if effects should be suspend or restored when a given effect is enable or disabled
Eric Laurenta85a74a2011-10-19 11:44:54 -07001805 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
Eric Laurent59255e42011-07-27 19:49:51 -07001806 bool enabled);
1807
Eric Laurent91b14c42012-05-30 12:30:29 -07001808 void clearInputBuffer();
1809
Glenn Kastenbe5f05e2012-07-18 15:24:02 -07001810 void dump(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001811
1812 protected:
Glenn Kasten19986612012-03-09 12:07:30 -08001813 friend class AudioFlinger; // for mThread, mEffects
Mathias Agopian65ab4712010-07-14 17:59:35 -07001814 EffectChain(const EffectChain&);
1815 EffectChain& operator =(const EffectChain&);
1816
Eric Laurent59255e42011-07-27 19:49:51 -07001817 class SuspendedEffectDesc : public RefBase {
1818 public:
1819 SuspendedEffectDesc() : mRefCount(0) {}
1820
1821 int mRefCount;
1822 effect_uuid_t mType;
1823 wp<EffectModule> mEffect;
1824 };
1825
1826 // get a list of effect modules to suspend when an effect of the type
1827 // passed is enabled.
Glenn Kastend0539712012-01-30 12:56:03 -08001828 void getSuspendEligibleEffects(Vector< sp<EffectModule> > &effects);
1829
Eric Laurent59255e42011-07-27 19:49:51 -07001830 // get an effect module if it is currently enable
1831 sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type);
Eric Laurentdb7c0792011-08-10 10:37:50 -07001832 // true if the effect whose descriptor is passed can be suspended
1833 // OEMs can modify the rules implemented in this method to exclude specific effect
1834 // types or implementations from the suspend/restore mechanism.
1835 bool isEffectEligibleForSuspend(const effect_descriptor_t& desc);
Eric Laurent59255e42011-07-27 19:49:51 -07001836
Eric Laurent91b14c42012-05-30 12:30:29 -07001837 void clearInputBuffer_l(sp<ThreadBase> thread);
1838
Mathias Agopian65ab4712010-07-14 17:59:35 -07001839 wp<ThreadBase> mThread; // parent mixer thread
1840 Mutex mLock; // mutex protecting effect list
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001841 Vector< sp<EffectModule> > mEffects; // list of effect modules
Mathias Agopian65ab4712010-07-14 17:59:35 -07001842 int mSessionId; // audio session ID
1843 int16_t *mInBuffer; // chain input buffer
1844 int16_t *mOutBuffer; // chain output buffer
Glenn Kasten2df8f552012-07-09 16:46:23 -07001845
1846 // 'volatile' here means these are accessed with atomic operations instead of mutex
1847 volatile int32_t mActiveTrackCnt; // number of active tracks connected
1848 volatile int32_t mTrackCnt; // number of tracks connected
1849
Eric Laurent544fe9b2011-11-11 15:42:52 -08001850 int32_t mTailBufferCount; // current effect tail buffer count
1851 int32_t mMaxTailBuffers; // maximum effect tail buffers
Mathias Agopian65ab4712010-07-14 17:59:35 -07001852 bool mOwnInBuffer; // true if the chain owns its input buffer
Eric Laurentcab11242010-07-15 12:50:15 -07001853 int mVolumeCtrlIdx; // index of insert effect having control over volume
1854 uint32_t mLeftVolume; // previous volume on left channel
1855 uint32_t mRightVolume; // previous volume on right channel
Eric Laurentf997cab2010-07-19 06:24:46 -07001856 uint32_t mNewLeftVolume; // new volume on left channel
1857 uint32_t mNewRightVolume; // new volume on right channel
Eric Laurentde070132010-07-13 04:45:46 -07001858 uint32_t mStrategy; // strategy for this effect chain
Glenn Kasten17a736c2012-02-14 08:52:15 -08001859 // mSuspendedEffects lists all effects currently suspended in the chain.
1860 // Use effect type UUID timelow field as key. There is no real risk of identical
Eric Laurent59255e42011-07-27 19:49:51 -07001861 // timeLow fields among effect type UUIDs.
Glenn Kasten17a736c2012-02-14 08:52:15 -08001862 // Updated by updateSuspendedSessions_l() only.
Eric Laurent59255e42011-07-27 19:49:51 -07001863 KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001864 };
1865
John Grossmanee578c02012-07-23 17:05:46 -07001866 class AudioHwDevice {
1867 public:
1868 enum Flags {
1869 AHWD_CAN_SET_MASTER_VOLUME = 0x1,
1870 AHWD_CAN_SET_MASTER_MUTE = 0x2,
1871 };
1872
1873 AudioHwDevice(const char *moduleName,
1874 audio_hw_device_t *hwDevice,
1875 Flags flags)
1876 : mModuleName(strdup(moduleName))
1877 , mHwDevice(hwDevice)
1878 , mFlags(flags) { }
1879 /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); }
1880
1881 bool canSetMasterVolume() const {
1882 return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
1883 }
1884
1885 bool canSetMasterMute() const {
1886 return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
1887 }
1888
1889 const char *moduleName() const { return mModuleName; }
1890 audio_hw_device_t *hwDevice() const { return mHwDevice; }
1891 private:
1892 const char * const mModuleName;
1893 audio_hw_device_t * const mHwDevice;
1894 Flags mFlags;
1895 };
1896
Glenn Kastenaed850d2012-01-26 09:46:34 -08001897 // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
1898 // For emphasis, we could also make all pointers to them be "const *",
1899 // but that would clutter the code unnecessarily.
1900
Dima Zavin799a70e2011-04-18 16:57:27 -07001901 struct AudioStreamOut {
John Grossmanee578c02012-07-23 17:05:46 -07001902 AudioHwDevice* const audioHwDev;
Glenn Kastenaed850d2012-01-26 09:46:34 -08001903 audio_stream_out_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -07001904
John Grossmanee578c02012-07-23 17:05:46 -07001905 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
1906
1907 AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out) :
1908 audioHwDev(dev), stream(out) {}
Dima Zavin799a70e2011-04-18 16:57:27 -07001909 };
1910
1911 struct AudioStreamIn {
John Grossmanee578c02012-07-23 17:05:46 -07001912 AudioHwDevice* const audioHwDev;
Glenn Kastenaed850d2012-01-26 09:46:34 -08001913 audio_stream_in_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -07001914
John Grossmanee578c02012-07-23 17:05:46 -07001915 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
1916
1917 AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) :
1918 audioHwDev(dev), stream(in) {}
Dima Zavin799a70e2011-04-18 16:57:27 -07001919 };
1920
Glenn Kasten99e53b82012-01-19 08:59:58 -08001921 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001922 struct AudioSessionRef {
Glenn Kasten012ca6b2012-03-06 11:22:01 -08001923 AudioSessionRef(int sessionid, pid_t pid) :
1924 mSessionid(sessionid), mPid(pid), mCnt(1) {}
1925 const int mSessionid;
1926 const pid_t mPid;
1927 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001928 };
1929
Mathias Agopian65ab4712010-07-14 17:59:35 -07001930 mutable Mutex mLock;
1931
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001932 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001933
1934 mutable Mutex mHardwareLock;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001935 // NOTE: If both mLock and mHardwareLock mutexes must be held,
1936 // always take mLock before mHardwareLock
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001937
1938 // These two fields are immutable after onFirstRef(), so no lock needed to access
John Grossmanee578c02012-07-23 17:05:46 -07001939 AudioHwDevice* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
Eric Laurenta4c5a552012-03-29 10:12:40 -07001940 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001941
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001942 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001943 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001944 AUDIO_HW_IDLE = 0, // no operation in progress
1945 AUDIO_HW_INIT, // init_check
1946 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
1947 AUDIO_HW_OUTPUT_CLOSE, // unused
1948 AUDIO_HW_INPUT_OPEN, // unused
1949 AUDIO_HW_INPUT_CLOSE, // unused
1950 AUDIO_HW_STANDBY, // unused
1951 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
1952 AUDIO_HW_GET_ROUTING, // unused
1953 AUDIO_HW_SET_ROUTING, // unused
1954 AUDIO_HW_GET_MODE, // unused
1955 AUDIO_HW_SET_MODE, // set_mode
1956 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
1957 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
1958 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
1959 AUDIO_HW_SET_PARAMETER, // set_parameters
1960 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
1961 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
1962 AUDIO_HW_GET_PARAMETER, // get_parameters
John Grossmand8f178d2012-07-20 14:51:35 -07001963 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute
1964 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute
Glenn Kasten2f732eb2012-01-26 09:48:03 -08001965 };
1966
Glenn Kastena4454b42012-01-04 11:02:33 -08001967 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -07001968
1969
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001970 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -08001971 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -08001972
Glenn Kastenc3ae93f2012-07-30 10:59:30 -07001973 // member variables below are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -07001974 float mMasterVolume;
1975 bool mMasterMute;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -07001976 // end of variables protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -07001977
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001978 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001979
1980 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kasten99e53b82012-01-19 08:59:58 -08001981 volatile int32_t mNextUniqueId; // updated by android_atomic_inc
Glenn Kastenf78aee72012-01-04 11:00:47 -08001982 audio_mode_t mMode;
Eric Laurentbee53372011-08-29 12:42:48 -07001983 bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001984
Glenn Kasten99e53b82012-01-19 08:59:58 -08001985 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001986 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -08001987
John Grossman4ff14ba2012-02-08 16:37:41 -08001988 float masterVolume_l() const;
John Grossmand8f178d2012-07-20 14:51:35 -07001989 bool masterMute_l() const;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001990 audio_module_handle_t loadHwModule_l(const char *name);
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001991
Eric Laurenta011e352012-03-29 15:51:43 -07001992 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
1993 // to be created
1994
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001995private:
1996 sp<Client> registerPid_l(pid_t pid); // always returns non-0
1997
Glenn Kastend96c5722012-04-25 13:44:49 -07001998 // for use from destructor
1999 status_t closeOutput_nonvirtual(audio_io_handle_t output);
2000 status_t closeInput_nonvirtual(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002001};
2002
Dima Zavin799a70e2011-04-18 16:57:27 -07002003
Mathias Agopian65ab4712010-07-14 17:59:35 -07002004// ----------------------------------------------------------------------------
2005
2006}; // namespace android
2007
2008#endif // ANDROID_AUDIO_FLINGER_H