blob: 46a8e0f9b4fbb2a69c429c6ea511de01f7579211 [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
Eric Laurent81784c32012-11-19 14:55:58 -080078#define MAX_GAIN 4096.0f
79#define MAX_GAIN_INT 0x1000
80
81#define INCLUDING_FROM_AUDIOFLINGER_H
82
Mathias Agopian5462fc92010-07-14 18:41:18 -070083class AudioFlinger :
84 public BinderService<AudioFlinger>,
85 public BnAudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -070086{
Glenn Kasten19986612012-03-09 12:07:30 -080087 friend class BinderService<AudioFlinger>; // for AudioFlinger()
Mathias Agopian65ab4712010-07-14 17:59:35 -070088public:
Glenn Kasten54c3b662012-01-06 07:46:30 -080089 static const char* getServiceName() { return "media.audio_flinger"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -070090
91 virtual status_t dump(int fd, const Vector<String16>& args);
92
Glenn Kasten2f732eb2012-01-26 09:48:03 -080093 // IAudioFlinger interface, in binder opcode order
Mathias Agopian65ab4712010-07-14 17:59:35 -070094 virtual sp<IAudioTrack> createTrack(
95 pid_t pid,
Glenn Kastenfff6d712012-01-12 16:38:12 -080096 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -070097 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -080098 audio_format_t format,
Glenn Kastendd8104c2012-07-02 12:42:44 -070099 audio_channel_mask_t channelMask,
Glenn Kastene33054e2012-11-14 12:54:39 -0800100 size_t frameCount,
Glenn Kastene0b07172012-11-06 15:03:34 -0800101 IAudioFlinger::track_flags_t *flags,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700102 const sp<IMemory>& sharedBuffer,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800103 audio_io_handle_t output,
Glenn Kasten3acbd052012-02-28 10:39:56 -0800104 pid_t tid,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700105 int *sessionId,
106 status_t *status);
107
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800108 virtual sp<IAudioRecord> openRecord(
109 pid_t pid,
110 audio_io_handle_t input,
111 uint32_t sampleRate,
112 audio_format_t format,
Glenn Kastendd8104c2012-07-02 12:42:44 -0700113 audio_channel_mask_t channelMask,
Glenn Kastene33054e2012-11-14 12:54:39 -0800114 size_t frameCount,
Glenn Kastena075db42012-03-06 11:22:44 -0800115 IAudioFlinger::track_flags_t flags,
Glenn Kasten1879fff2012-07-11 15:36:59 -0700116 pid_t tid,
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800117 int *sessionId,
118 status_t *status);
119
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800120 virtual uint32_t sampleRate(audio_io_handle_t output) const;
121 virtual int channelCount(audio_io_handle_t output) const;
122 virtual audio_format_t format(audio_io_handle_t output) const;
123 virtual size_t frameCount(audio_io_handle_t output) const;
124 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700125
126 virtual status_t setMasterVolume(float value);
127 virtual status_t setMasterMute(bool muted);
128
129 virtual float masterVolume() const;
130 virtual bool masterMute() const;
131
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800132 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
133 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800134 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700135
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800136 virtual float streamVolume(audio_stream_type_t stream,
137 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800138 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700139
Glenn Kastenf78aee72012-01-04 11:00:47 -0800140 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700141
142 virtual status_t setMicMute(bool state);
143 virtual bool getMicMute() const;
144
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800145 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
146 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700147
148 virtual void registerClient(const sp<IAudioFlingerClient>& client);
149
Glenn Kastendd8104c2012-07-02 12:42:44 -0700150 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
151 audio_channel_mask_t channelMask) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700152
Eric Laurenta4c5a552012-03-29 10:12:40 -0700153 virtual audio_io_handle_t openOutput(audio_module_handle_t module,
154 audio_devices_t *pDevices,
155 uint32_t *pSamplingRate,
156 audio_format_t *pFormat,
157 audio_channel_mask_t *pChannelMask,
158 uint32_t *pLatencyMs,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700159 audio_output_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700160
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800161 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
162 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700163
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800164 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700165
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800166 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700167
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800168 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700169
Eric Laurenta4c5a552012-03-29 10:12:40 -0700170 virtual audio_io_handle_t openInput(audio_module_handle_t module,
171 audio_devices_t *pDevices,
172 uint32_t *pSamplingRate,
173 audio_format_t *pFormat,
174 audio_channel_mask_t *pChannelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700175
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800176 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700177
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800178 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700179
180 virtual status_t setVoiceVolume(float volume);
181
Glenn Kasten26c77552012-11-16 12:01:44 -0800182 virtual status_t getRenderPosition(size_t *halFrames, size_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800183 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700184
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800185 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const;
186
Mathias Agopian65ab4712010-07-14 17:59:35 -0700187 virtual int newAudioSessionId();
188
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700189 virtual void acquireAudioSessionId(int audioSession);
190
191 virtual void releaseAudioSessionId(int audioSession);
192
Glenn Kastenf587ba52012-01-26 16:25:10 -0800193 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700194
Glenn Kastenf587ba52012-01-26 16:25:10 -0800195 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700196
Glenn Kasten5e92a782012-01-30 07:40:52 -0800197 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800198 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700199
200 virtual sp<IEffect> createEffect(pid_t pid,
201 effect_descriptor_t *pDesc,
202 const sp<IEffectClient>& effectClient,
203 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800204 audio_io_handle_t io,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700205 int sessionId,
206 status_t *status,
207 int *id,
208 int *enabled);
209
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800210 virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
211 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700212
Eric Laurenta4c5a552012-03-29 10:12:40 -0700213 virtual audio_module_handle_t loadHwModule(const char *name);
214
Glenn Kasten3b16c762012-11-14 08:44:39 -0800215 virtual uint32_t getPrimaryOutputSamplingRate();
Glenn Kastene33054e2012-11-14 12:54:39 -0800216 virtual size_t getPrimaryOutputFrameCount();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -0700217
Mathias Agopian65ab4712010-07-14 17:59:35 -0700218 virtual status_t onTransact(
219 uint32_t code,
220 const Parcel& data,
221 Parcel* reply,
222 uint32_t flags);
223
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800224 // end of IAudioFlinger interface
225
Eric Laurenta011e352012-03-29 15:51:43 -0700226 class SyncEvent;
227
228 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
229
230 class SyncEvent : public RefBase {
231 public:
232 SyncEvent(AudioSystem::sync_event_t type,
233 int triggerSession,
234 int listenerSession,
235 sync_event_callback_t callBack,
236 void *cookie)
237 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
238 mCallback(callBack), mCookie(cookie)
239 {}
240
241 virtual ~SyncEvent() {}
242
243 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
Glenn Kasten106e8a42012-08-02 13:37:12 -0700244 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
245 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
Eric Laurenta011e352012-03-29 15:51:43 -0700246 AudioSystem::sync_event_t type() const { return mType; }
247 int triggerSession() const { return mTriggerSession; }
248 int listenerSession() const { return mListenerSession; }
249 void *cookie() const { return mCookie; }
250
251 private:
252 const AudioSystem::sync_event_t mType;
253 const int mTriggerSession;
254 const int mListenerSession;
255 sync_event_callback_t mCallback;
256 void * const mCookie;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700257 mutable Mutex mLock;
Eric Laurenta011e352012-03-29 15:51:43 -0700258 };
259
260 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
261 int triggerSession,
262 int listenerSession,
263 sync_event_callback_t callBack,
264 void *cookie);
Eric Laurent717e1282012-06-29 16:36:52 -0700265
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800266private:
John Grossmanee578c02012-07-23 17:05:46 -0700267 class AudioHwDevice; // fwd declaration for findSuitableHwDev_l
268
Glenn Kastenf78aee72012-01-04 11:00:47 -0800269 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700270
Glenn Kastenc59c0042012-02-02 14:06:11 -0800271 bool btNrecIsOff() const { return mBtNrecIsOff; }
Eric Laurent59bd0da2011-08-01 09:52:20 -0700272
Mathias Agopian65ab4712010-07-14 17:59:35 -0700273 AudioFlinger();
274 virtual ~AudioFlinger();
275
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800276 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700277 status_t initCheck() const { return mPrimaryHardwareDev == NULL ?
278 NO_INIT : NO_ERROR; }
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800279
Glenn Kasten000f0e32012-03-01 17:10:56 -0800280 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700281 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800282
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700283 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module,
284 audio_devices_t devices);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700285 void purgeStaleEffects_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700286
Glenn Kasten66fcab92012-02-24 14:59:21 -0800287 // standby delay for MIXER and DUPLICATING playback threads is read from property
288 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
John Grossman4ff14ba2012-02-08 16:37:41 -0800289 static nsecs_t mStandbyTimeInNsecs;
290
Eric Laurent81784c32012-11-19 14:55:58 -0800291 // incremented by 2 when screen state changes, bit 0 == 1 means "off"
292 // AudioFlinger::setParameters() updates, other threads read w/o lock
293 static uint32_t mScreenState;
294
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700295 // Internal dump utilities.
Eric Laurent81784c32012-11-19 14:55:58 -0800296 static const int kDumpLockRetries = 50;
297 static const int kDumpLockSleepUs = 20000;
298 static bool dumpTryLock(Mutex& mutex);
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700299 void dumpPermissionDenial(int fd, const Vector<String16>& args);
300 void dumpClients(int fd, const Vector<String16>& args);
301 void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700302
303 // --- Client ---
304 class Client : public RefBase {
305 public:
306 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
307 virtual ~Client();
Glenn Kasten435dbe62012-01-30 10:15:48 -0800308 sp<MemoryDealer> heap() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700309 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800310 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700311
John Grossman4ff14ba2012-02-08 16:37:41 -0800312 bool reserveTimedTrack();
313 void releaseTimedTrack();
314
Mathias Agopian65ab4712010-07-14 17:59:35 -0700315 private:
316 Client(const Client&);
317 Client& operator = (const Client&);
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800318 const sp<AudioFlinger> mAudioFlinger;
319 const sp<MemoryDealer> mMemoryDealer;
320 const pid_t mPid;
John Grossman4ff14ba2012-02-08 16:37:41 -0800321
322 Mutex mTimedTrackLock;
323 int mTimedTrackCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700324 };
325
326 // --- Notification Client ---
327 class NotificationClient : public IBinder::DeathRecipient {
328 public:
329 NotificationClient(const sp<AudioFlinger>& audioFlinger,
330 const sp<IAudioFlingerClient>& client,
331 pid_t pid);
332 virtual ~NotificationClient();
333
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800334 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700335
336 // IBinder::DeathRecipient
337 virtual void binderDied(const wp<IBinder>& who);
338
339 private:
340 NotificationClient(const NotificationClient&);
341 NotificationClient& operator = (const NotificationClient&);
342
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800343 const sp<AudioFlinger> mAudioFlinger;
344 const pid_t mPid;
345 const sp<IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700346 };
347
348 class TrackHandle;
349 class RecordHandle;
350 class RecordThread;
351 class PlaybackThread;
352 class MixerThread;
353 class DirectOutputThread;
354 class DuplicatingThread;
355 class Track;
356 class RecordTrack;
357 class EffectModule;
358 class EffectHandle;
359 class EffectChain;
Dima Zavin799a70e2011-04-18 16:57:27 -0700360 struct AudioStreamOut;
361 struct AudioStreamIn;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700362
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800363 struct stream_type_t {
364 stream_type_t()
365 : volume(1.0f),
Eric Laurent1a9ed112012-03-20 18:36:01 -0700366 mute(false)
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800367 {
368 }
369 float volume;
370 bool mute;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800371 };
372
Mathias Agopian65ab4712010-07-14 17:59:35 -0700373 // --- PlaybackThread ---
Eric Laurent81784c32012-11-19 14:55:58 -0800374
375#include "Threads.h"
376
377#include "Effects.h"
378
379 // server side of the client's IAudioTrack
380 class TrackHandle : public android::BnAudioTrack {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700381 public:
Eric Laurent81784c32012-11-19 14:55:58 -0800382 TrackHandle(const sp<PlaybackThread::Track>& track);
383 virtual ~TrackHandle();
384 virtual sp<IMemory> getCblk() const;
385 virtual status_t start();
386 virtual void stop();
387 virtual void flush();
388 virtual void mute(bool);
389 virtual void pause();
390 virtual status_t attachAuxEffect(int effectId);
391 virtual status_t allocateTimedBuffer(size_t size,
392 sp<IMemory>* buffer);
393 virtual status_t queueTimedBuffer(const sp<IMemory>& buffer,
394 int64_t pts);
395 virtual status_t setMediaTimeTransform(const LinearTransform& xform,
396 int target);
397 virtual status_t onTransact(
398 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
Glenn Kasten98067102011-12-13 11:47:54 -0800399 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800400 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700401 };
402
Eric Laurent81784c32012-11-19 14:55:58 -0800403 // server side of the client's IAudioRecord
404 class RecordHandle : public android::BnAudioRecord {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700405 public:
Eric Laurent81784c32012-11-19 14:55:58 -0800406 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
407 virtual ~RecordHandle();
408 virtual sp<IMemory> getCblk() const;
409 virtual status_t start(int /*AudioSystem::sync_event_t*/ event, int triggerSession);
410 virtual void stop();
411 virtual status_t onTransact(
412 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
Glenn Kasten58912562012-04-03 10:45:00 -0700413 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800414 const sp<RecordThread::RecordTrack> mRecordTrack;
Glenn Kasten58912562012-04-03 10:45:00 -0700415
Eric Laurent81784c32012-11-19 14:55:58 -0800416 // for use from destructor
417 void stop_nonvirtual();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700418 };
419
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800420 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
421 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
422 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Glenn Kasten6637baa2012-01-09 09:40:36 -0800423 // no range check, AudioFlinger::mLock held
424 bool streamMute_l(audio_stream_type_t stream) const
425 { return mStreamTypes[stream].mute; }
426 // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
427 float streamVolume_l(audio_stream_type_t stream) const
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800428 { return mStreamTypes[stream].volume; }
Glenn Kastenb81cc8c2012-03-01 09:14:51 -0800429 void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700430
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800431 // allocate an audio_io_handle_t, session ID, or effect ID
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700432 uint32_t nextUniqueId();
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800433
Eric Laurent59255e42011-07-27 19:49:51 -0700434 status_t moveEffectChain_l(int sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -0800435 PlaybackThread *srcThread,
436 PlaybackThread *dstThread,
Eric Laurent39e94f82010-07-28 01:32:47 -0700437 bool reRegister);
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800438 // return thread associated with primary hardware device, or NULL
439 PlaybackThread *primaryPlaybackThread_l() const;
Glenn Kastenbb4350d2012-07-03 15:56:38 -0700440 audio_devices_t primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700441
Eric Laurent717e1282012-06-29 16:36:52 -0700442 sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId);
443
Mathias Agopian65ab4712010-07-14 17:59:35 -0700444
Mathias Agopian65ab4712010-07-14 17:59:35 -0700445 void removeClient_l(pid_t pid);
446 void removeNotificationClient(pid_t pid);
447
John Grossmanee578c02012-07-23 17:05:46 -0700448 class AudioHwDevice {
449 public:
450 enum Flags {
451 AHWD_CAN_SET_MASTER_VOLUME = 0x1,
452 AHWD_CAN_SET_MASTER_MUTE = 0x2,
453 };
454
455 AudioHwDevice(const char *moduleName,
456 audio_hw_device_t *hwDevice,
457 Flags flags)
458 : mModuleName(strdup(moduleName))
459 , mHwDevice(hwDevice)
460 , mFlags(flags) { }
461 /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); }
462
463 bool canSetMasterVolume() const {
464 return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
465 }
466
467 bool canSetMasterMute() const {
468 return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
469 }
470
471 const char *moduleName() const { return mModuleName; }
472 audio_hw_device_t *hwDevice() const { return mHwDevice; }
473 private:
474 const char * const mModuleName;
475 audio_hw_device_t * const mHwDevice;
476 Flags mFlags;
477 };
478
Glenn Kastenaed850d2012-01-26 09:46:34 -0800479 // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
480 // For emphasis, we could also make all pointers to them be "const *",
481 // but that would clutter the code unnecessarily.
482
Dima Zavin799a70e2011-04-18 16:57:27 -0700483 struct AudioStreamOut {
John Grossmanee578c02012-07-23 17:05:46 -0700484 AudioHwDevice* const audioHwDev;
Glenn Kastenaed850d2012-01-26 09:46:34 -0800485 audio_stream_out_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -0700486
John Grossmanee578c02012-07-23 17:05:46 -0700487 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
488
489 AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out) :
490 audioHwDev(dev), stream(out) {}
Dima Zavin799a70e2011-04-18 16:57:27 -0700491 };
492
493 struct AudioStreamIn {
John Grossmanee578c02012-07-23 17:05:46 -0700494 AudioHwDevice* const audioHwDev;
Glenn Kastenaed850d2012-01-26 09:46:34 -0800495 audio_stream_in_t* const stream;
Dima Zavin799a70e2011-04-18 16:57:27 -0700496
John Grossmanee578c02012-07-23 17:05:46 -0700497 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
498
499 AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) :
500 audioHwDev(dev), stream(in) {}
Dima Zavin799a70e2011-04-18 16:57:27 -0700501 };
502
Glenn Kasten99e53b82012-01-19 08:59:58 -0800503 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700504 struct AudioSessionRef {
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800505 AudioSessionRef(int sessionid, pid_t pid) :
506 mSessionid(sessionid), mPid(pid), mCnt(1) {}
507 const int mSessionid;
508 const pid_t mPid;
509 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700510 };
511
Mathias Agopian65ab4712010-07-14 17:59:35 -0700512 mutable Mutex mLock;
513
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800514 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700515
516 mutable Mutex mHardwareLock;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700517 // NOTE: If both mLock and mHardwareLock mutexes must be held,
518 // always take mLock before mHardwareLock
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800519
520 // These two fields are immutable after onFirstRef(), so no lock needed to access
John Grossmanee578c02012-07-23 17:05:46 -0700521 AudioHwDevice* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
Eric Laurenta4c5a552012-03-29 10:12:40 -0700522 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800523
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800524 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800525 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800526 AUDIO_HW_IDLE = 0, // no operation in progress
527 AUDIO_HW_INIT, // init_check
528 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
529 AUDIO_HW_OUTPUT_CLOSE, // unused
530 AUDIO_HW_INPUT_OPEN, // unused
531 AUDIO_HW_INPUT_CLOSE, // unused
532 AUDIO_HW_STANDBY, // unused
533 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
534 AUDIO_HW_GET_ROUTING, // unused
535 AUDIO_HW_SET_ROUTING, // unused
536 AUDIO_HW_GET_MODE, // unused
537 AUDIO_HW_SET_MODE, // set_mode
538 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
539 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
540 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
541 AUDIO_HW_SET_PARAMETER, // set_parameters
542 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
543 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
544 AUDIO_HW_GET_PARAMETER, // get_parameters
John Grossmand8f178d2012-07-20 14:51:35 -0700545 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute
546 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800547 };
548
Glenn Kastena4454b42012-01-04 11:02:33 -0800549 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -0700550
551
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800552 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800553 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -0800554
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700555 // member variables below are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700556 float mMasterVolume;
557 bool mMasterMute;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700558 // end of variables protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700559
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800560 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700561
562 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kasten99e53b82012-01-19 08:59:58 -0800563 volatile int32_t mNextUniqueId; // updated by android_atomic_inc
Glenn Kastenf78aee72012-01-04 11:00:47 -0800564 audio_mode_t mMode;
Eric Laurentbee53372011-08-29 12:42:48 -0700565 bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700566
Glenn Kasten99e53b82012-01-19 08:59:58 -0800567 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700568 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -0800569
John Grossman4ff14ba2012-02-08 16:37:41 -0800570 float masterVolume_l() const;
John Grossmand8f178d2012-07-20 14:51:35 -0700571 bool masterMute_l() const;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700572 audio_module_handle_t loadHwModule_l(const char *name);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800573
Eric Laurenta011e352012-03-29 15:51:43 -0700574 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
575 // to be created
576
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800577private:
578 sp<Client> registerPid_l(pid_t pid); // always returns non-0
579
Glenn Kastend96c5722012-04-25 13:44:49 -0700580 // for use from destructor
581 status_t closeOutput_nonvirtual(audio_io_handle_t output);
582 status_t closeInput_nonvirtual(audio_io_handle_t input);
Glenn Kastend06785b2012-09-30 12:29:28 -0700583
584 // all record threads serially share a common tee sink, which is re-created on format change
585 sp<NBAIO_Sink> mRecordTeeSink;
586 sp<NBAIO_Source> mRecordTeeSource;
587
588public:
589 static void dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700590};
591
Eric Laurent81784c32012-11-19 14:55:58 -0800592#undef INCLUDING_FROM_AUDIOFLINGER_H
Dima Zavin799a70e2011-04-18 16:57:27 -0700593
Mathias Agopian65ab4712010-07-14 17:59:35 -0700594// ----------------------------------------------------------------------------
595
596}; // namespace android
597
598#endif // ANDROID_AUDIO_FLINGER_H