Gitiles
Code Review Sign In
review.blissroms.org / platform_frameworks_native / bcef13b666c7459241235bc6209837ae81884d2f / . / libs / audioflinger / AudioFlinger.h
blob: 596e7f3b11e40f9c2cbd9abf52aac479802237d9 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]1/* //device/include/server/AudioFlinger/AudioFlinger.h
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef ANDROID_AUDIO_FLINGER_H
19#define ANDROID_AUDIO_FLINGER_H
20
21#include <stdint.h>
22#include <sys/types.h>
23
24#include <media/IAudioFlinger.h>
25#include <media/IAudioFlingerClient.h>
26#include <media/IAudioTrack.h>
27#include <media/IAudioRecord.h>
28#include <media/AudioTrack.h>
29
30#include <utils/Atomic.h>
31#include <utils/Errors.h>
32#include <utils/threads.h>
33#include <utils/MemoryDealer.h>
34#include <utils/KeyedVector.h>
35#include <utils/SortedVector.h>
36#include <utils/Vector.h>
37
38#include <hardware_legacy/AudioHardwareInterface.h>
39
40#include "AudioBufferProvider.h"
41
42namespace android {
43
44class audio_track_cblk_t;
45class AudioMixer;
46class AudioBuffer;
47
48
49// ----------------------------------------------------------------------------
50
51#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
52#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
53
54
55// ----------------------------------------------------------------------------
56
57static const nsecs_t kStandbyTimeInNsecs = seconds(3);
58
59class AudioFlinger : public BnAudioFlinger, public IBinder::DeathRecipient
60{
61public:
62 static void instantiate();
63
64 virtual status_t dump(int fd, const Vector<String16>& args);
65
66 // IAudioFlinger interface
67 virtual sp<IAudioTrack> createTrack(
68 pid_t pid,
69 int streamType,
70 uint32_t sampleRate,
71 int format,
72 int channelCount,
73 int frameCount,
74 uint32_t flags,
75 const sp<IMemory>& sharedBuffer,
76 status_t *status);
77
78 virtual uint32_t sampleRate(int output) const;
79 virtual int channelCount(int output) const;
80 virtual int format(int output) const;
81 virtual size_t frameCount(int output) const;
82 virtual uint32_t latency(int output) const;
83
84 virtual status_t setMasterVolume(float value);
85 virtual status_t setMasterMute(bool muted);
86
87 virtual float masterVolume() const;
88 virtual bool masterMute() const;
89
90 virtual status_t setStreamVolume(int stream, float value);
91 virtual status_t setStreamMute(int stream, bool muted);
92
93 virtual float streamVolume(int stream) const;
94 virtual bool streamMute(int stream) const;
95
96 virtual status_t setRouting(int mode, uint32_t routes, uint32_t mask);
97 virtual uint32_t getRouting(int mode) const;
98
99 virtual status_t setMode(int mode);
100 virtual int getMode() const;
101
102 virtual status_t setMicMute(bool state);
103 virtual bool getMicMute() const;
104
105 virtual bool isMusicActive() const;
106
107 virtual bool isA2dpEnabled() const;
108
109 virtual status_t setParameter(const char* key, const char* value);
110
111 virtual void registerClient(const sp<IAudioFlingerClient>& client);
112
113 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
114
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]115 virtual void wakeUp() { mWaitWorkCV.broadcast(); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]116
117 // IBinder::DeathRecipient
118 virtual void binderDied(const wp<IBinder>& who);
119
120 enum hardware_call_state {
121 AUDIO_HW_IDLE = 0,
122 AUDIO_HW_INIT,
123 AUDIO_HW_OUTPUT_OPEN,
124 AUDIO_HW_OUTPUT_CLOSE,
125 AUDIO_HW_INPUT_OPEN,
126 AUDIO_HW_INPUT_CLOSE,
127 AUDIO_HW_STANDBY,
128 AUDIO_HW_SET_MASTER_VOLUME,
129 AUDIO_HW_GET_ROUTING,
130 AUDIO_HW_SET_ROUTING,
131 AUDIO_HW_GET_MODE,
132 AUDIO_HW_SET_MODE,
133 AUDIO_HW_GET_MIC_MUTE,
134 AUDIO_HW_SET_MIC_MUTE,
135 AUDIO_SET_VOICE_VOLUME,
136 AUDIO_SET_PARAMETER,
137 };
138
139 // record interface
140 virtual sp<IAudioRecord> openRecord(
141 pid_t pid,
142 int streamType,
143 uint32_t sampleRate,
144 int format,
145 int channelCount,
146 int frameCount,
147 uint32_t flags,
148 status_t *status);
149
150 virtual status_t onTransact(
151 uint32_t code,
152 const Parcel& data,
153 Parcel* reply,
154 uint32_t flags);
155
156private:
157 AudioFlinger();
158 virtual ~AudioFlinger();
159
160 void setOutput(int outputType);
161 void doSetOutput(int outputType);
162
163#ifdef WITH_A2DP
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]164 void setA2dpEnabled_l(bool enable);
165 void checkA2dpEnabledChange_l();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]166#endif
167 static bool streamForcedToSpeaker(int streamType);
The Android Open Source Projectbcef13b2009-03-11 12:11:56 -0700[diff] [blame^]168 static bool streamDisablesA2dp(int streamType);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]169
170 // Management of forced route to speaker for certain track types.
171 enum force_speaker_command {
172 ACTIVE_TRACK_ADDED = 0,
173 ACTIVE_TRACK_REMOVED,
174 CHECK_ROUTE_RESTORE_TIME,
175 FORCE_ROUTE_RESTORE
176 };
177 void handleForcedSpeakerRoute(int command);
The Android Open Source Projectbcef13b2009-03-11 12:11:56 -0700[diff] [blame^]178#ifdef WITH_A2DP
179 void handleStreamDisablesA2dp(int command);
180#endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]181
182 // Internal dump utilites.
183 status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
184 status_t dumpClients(int fd, const Vector<String16>& args);
185 status_t dumpInternals(int fd, const Vector<String16>& args);
186
187 // --- Client ---
188 class Client : public RefBase {
189 public:
190 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
191 virtual ~Client();
192 const sp<MemoryDealer>& heap() const;
193 pid_t pid() const { return mPid; }
194 private:
195 Client(const Client&);
196 Client& operator = (const Client&);
197 sp<AudioFlinger> mAudioFlinger;
198 sp<MemoryDealer> mMemoryDealer;
199 pid_t mPid;
200 };
201
202
203 class TrackHandle;
204 class RecordHandle;
205 class AudioRecordThread;
206
207
208 // --- MixerThread ---
209 class MixerThread : public Thread {
210 public:
211
212 // --- Track ---
213
214 // base for record and playback
215 class TrackBase : public AudioBufferProvider, public RefBase {
216
217 public:
218 enum track_state {
219 IDLE,
220 TERMINATED,
221 STOPPED,
222 RESUMING,
223 ACTIVE,
224 PAUSING,
225 PAUSED
226 };
227
228 enum track_flags {
229 STEPSERVER_FAILED = 0x01, // StepServer could not acquire cblk->lock mutex
230 SYSTEM_FLAGS_MASK = 0x0000ffffUL,
231 // The upper 16 bits are used for track-specific flags.
232 };
233
234 TrackBase(const sp<MixerThread>& mixerThread,
235 const sp<Client>& client,
236 int streamType,
237 uint32_t sampleRate,
238 int format,
239 int channelCount,
240 int frameCount,
241 uint32_t flags,
242 const sp<IMemory>& sharedBuffer);
243 ~TrackBase();
244
245 virtual status_t start() = 0;
246 virtual void stop() = 0;
247 sp<IMemory> getCblk() const;
248
249 protected:
250 friend class MixerThread;
251 friend class RecordHandle;
252 friend class AudioRecordThread;
253
254 TrackBase(const TrackBase&);
255 TrackBase& operator = (const TrackBase&);
256
257 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
258 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
259
260 audio_track_cblk_t* cblk() const {
261 return mCblk;
262 }
263
264 int type() const {
265 return mStreamType;
266 }
267
268 int format() const {
269 return mFormat;
270 }
271
272 int channelCount() const ;
273
274 int sampleRate() const;
275
276 void* getBuffer(uint32_t offset, uint32_t frames) const;
277
278 int name() const {
279 return mName;
280 }
281
282 bool isStopped() const {
283 return mState == STOPPED;
284 }
285
286 bool isTerminated() const {
287 return mState == TERMINATED;
288 }
289
290 bool step();
291 void reset();
292
293 sp<MixerThread> mMixerThread;
294 sp<Client> mClient;
295 sp<IMemory> mCblkMemory;
296 audio_track_cblk_t* mCblk;
297 int mStreamType;
298 void* mBuffer;
299 void* mBufferEnd;
300 uint32_t mFrameCount;
301 int mName;
302 // we don't really need a lock for these
303 int mState;
304 int mClientTid;
305 uint8_t mFormat;
306 uint32_t mFlags;
307 };
308
309 // playback track
310 class Track : public TrackBase {
311 public:
312 Track( const sp<MixerThread>& mixerThread,
313 const sp<Client>& client,
314 int streamType,
315 uint32_t sampleRate,
316 int format,
317 int channelCount,
318 int frameCount,
319 const sp<IMemory>& sharedBuffer);
320 ~Track();
321
322 void dump(char* buffer, size_t size);
323 virtual status_t start();
324 virtual void stop();
325 void pause();
326
327 void flush();
328 void destroy();
329 void mute(bool);
330 void setVolume(float left, float right);
331
332 protected:
333 friend class MixerThread;
334 friend class AudioFlinger;
335 friend class AudioFlinger::TrackHandle;
336
337 Track(const Track&);
338 Track& operator = (const Track&);
339
340 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
341
342 bool isMuted() const {
343 return (mMute || mMixerThread->mStreamTypes[mStreamType].mute);
344 }
345
346 bool isPausing() const {
347 return mState == PAUSING;
348 }
349
350 bool isPaused() const {
351 return mState == PAUSED;
352 }
353
354 bool isReady() const;
355
356 void setPaused() { mState = PAUSED; }
357 void reset();
358
359 // we don't really need a lock for these
360 float mVolume[2];
361 volatile bool mMute;
362 // FILLED state is used for suppressing volume ramp at begin of playing
363 enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
364 mutable uint8_t mFillingUpStatus;
365 int8_t mRetryCount;
366 sp<IMemory> mSharedBuffer;
367 bool mResetDone;
368 }; // end of Track
369
370 // record track
371 class RecordTrack : public TrackBase {
372 public:
373 RecordTrack(const sp<MixerThread>& mixerThread,
374 const sp<Client>& client,
375 int streamType,
376 uint32_t sampleRate,
377 int format,
378 int channelCount,
379 int frameCount,
380 uint32_t flags);
381 ~RecordTrack();
382
383 virtual status_t start();
384 virtual void stop();
385
386 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
387 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
388
389 private:
390 friend class AudioFlinger;
391 friend class AudioFlinger::RecordHandle;
392 friend class AudioFlinger::AudioRecordThread;
393 friend class MixerThread;
394
395 RecordTrack(const Track&);
396 RecordTrack& operator = (const Track&);
397
398 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
399
400 bool mOverflow;
401 };
402
403 // playback track
404 class OutputTrack : public Track {
405 public:
406
407 class Buffer: public AudioBufferProvider::Buffer {
408 public:
409 int16_t *mBuffer;
410 };
411
412 OutputTrack( const sp<MixerThread>& mixerThread,
413 uint32_t sampleRate,
414 int format,
415 int channelCount,
416 int frameCount);
417 ~OutputTrack();
418
419 virtual status_t start();
420 virtual void stop();
421 void write(int16_t* data, uint32_t frames);
422 bool bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; }
423
424 private:
425
426 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer);
427 void clearBufferQueue();
428
429 sp<MixerThread> mOutputMixerThread;
430 Vector < Buffer* > mBufferQueue;
431 AudioBufferProvider::Buffer mOutBuffer;
432 uint32_t mFramesWritten;
433
434 }; // end of OutputTrack
435
436 MixerThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int outputType);
437 virtual ~MixerThread();
438
439 virtual status_t dump(int fd, const Vector<String16>& args);
440
441 // Thread virtuals
442 virtual bool threadLoop();
443 virtual status_t readyToRun();
444 virtual void onFirstRef();
445
446 virtual uint32_t sampleRate() const;
447 virtual int channelCount() const;
448 virtual int format() const;
449 virtual size_t frameCount() const;
450 virtual uint32_t latency() const;
451
452 virtual status_t setMasterVolume(float value);
453 virtual status_t setMasterMute(bool muted);
454
455 virtual float masterVolume() const;
456 virtual bool masterMute() const;
457
458 virtual status_t setStreamVolume(int stream, float value);
459 virtual status_t setStreamMute(int stream, bool muted);
460
461 virtual float streamVolume(int stream) const;
462 virtual bool streamMute(int stream) const;
463
464 bool isMusicActive() const;
465
466
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]467 sp<Track> createTrack_l(
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]468 const sp<AudioFlinger::Client>& client,
469 int streamType,
470 uint32_t sampleRate,
471 int format,
472 int channelCount,
473 int frameCount,
474 const sp<IMemory>& sharedBuffer,
475 status_t *status);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]476
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]477 void getTracks_l(SortedVector < sp<Track> >& tracks,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]478 SortedVector < wp<Track> >& activeTracks);
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]479 void putTracks_l(SortedVector < sp<Track> >& tracks,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]480 SortedVector < wp<Track> >& activeTracks);
481 void setOuputTrack(OutputTrack *track) { mOutputTrack = track; }
482
483 struct stream_type_t {
484 stream_type_t()
485 : volume(1.0f),
486 mute(false)
487 {
488 }
489 float volume;
490 bool mute;
491 };
492
493 private:
494
495
496 friend class AudioFlinger;
497 friend class Track;
498 friend class TrackBase;
499 friend class RecordTrack;
500
501 MixerThread(const Client&);
502 MixerThread& operator = (const MixerThread&);
503
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]504 status_t addTrack_l(const sp<Track>& track);
505 void removeTrack_l(wp<Track> track, int name);
506 void destroyTrack_l(const sp<Track>& track);
507 int getTrackName_l();
508 void deleteTrackName_l(int name);
509 void addActiveTrack_l(const wp<Track>& t);
510 void removeActiveTrack_l(const wp<Track>& t);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]511 size_t getOutputFrameCount();
512
513 status_t dumpInternals(int fd, const Vector<String16>& args);
514 status_t dumpTracks(int fd, const Vector<String16>& args);
515
516 sp<AudioFlinger> mAudioFlinger;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]517 SortedVector< wp<Track> > mActiveTracks;
518 SortedVector< sp<Track> > mTracks;
519 stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES];
520 AudioMixer* mAudioMixer;
521 AudioStreamOut* mOutput;
522 int mOutputType;
523 uint32_t mSampleRate;
524 size_t mFrameCount;
525 int mChannelCount;
526 int mFormat;
527 int16_t* mMixBuffer;
528 float mMasterVolume;
529 bool mMasterMute;
530 nsecs_t mLastWriteTime;
531 int mNumWrites;
532 int mNumDelayedWrites;
533 bool mStandby;
534 bool mInWrite;
535 sp <OutputTrack> mOutputTrack;
536 };
537
538
539 friend class AudioBuffer;
540
541 class TrackHandle : public android::BnAudioTrack {
542 public:
543 TrackHandle(const sp<MixerThread::Track>& track);
544 virtual ~TrackHandle();
545 virtual status_t start();
546 virtual void stop();
547 virtual void flush();
548 virtual void mute(bool);
549 virtual void pause();
550 virtual void setVolume(float left, float right);
551 virtual sp<IMemory> getCblk() const;
552 virtual status_t onTransact(
553 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
554 private:
555 sp<MixerThread::Track> mTrack;
556 };
557
558 friend class Client;
559 friend class MixerThread::Track;
560
561
562 void removeClient(pid_t pid);
563
564
565
566 class RecordHandle : public android::BnAudioRecord {
567 public:
568 RecordHandle(const sp<MixerThread::RecordTrack>& recordTrack);
569 virtual ~RecordHandle();
570 virtual status_t start();
571 virtual void stop();
572 virtual sp<IMemory> getCblk() const;
573 virtual status_t onTransact(
574 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
575 private:
576 sp<MixerThread::RecordTrack> mRecordTrack;
577 };
578
579 // record thread
580 class AudioRecordThread : public Thread
581 {
582 public:
The Android Open Source Projectbcef13b2009-03-11 12:11:56 -0700[diff] [blame^]583 AudioRecordThread(AudioHardwareInterface* audioHardware, const sp<AudioFlinger>& audioFlinger);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]584 virtual ~AudioRecordThread();
585 virtual bool threadLoop();
586 virtual status_t readyToRun() { return NO_ERROR; }
587 virtual void onFirstRef() {}
588
589 status_t start(MixerThread::RecordTrack* recordTrack);
590 void stop(MixerThread::RecordTrack* recordTrack);
591 void exit();
592 status_t dump(int fd, const Vector<String16>& args);
593
594 private:
595 AudioRecordThread();
596 AudioHardwareInterface *mAudioHardware;
The Android Open Source Projectbcef13b2009-03-11 12:11:56 -0700[diff] [blame^]597 sp<AudioFlinger> mAudioFlinger;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]598 sp<MixerThread::RecordTrack> mRecordTrack;
599 Mutex mLock;
600 Condition mWaitWorkCV;
601 Condition mStopped;
602 volatile bool mActive;
603 status_t mStartStatus;
604 };
605
606 friend class AudioRecordThread;
607 friend class MixerThread;
608
609 status_t startRecord(MixerThread::RecordTrack* recordTrack);
610 void stopRecord(MixerThread::RecordTrack* recordTrack);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]611
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]612 mutable Mutex mHardwareLock;
613 mutable Mutex mLock;
614 mutable Condition mWaitWorkCV;
615
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]616 DefaultKeyedVector< pid_t, wp<Client> > mClients;
617
618 sp<MixerThread> mA2dpMixerThread;
619 sp<MixerThread> mHardwareMixerThread;
620 AudioHardwareInterface* mAudioHardware;
621 AudioHardwareInterface* mA2dpAudioInterface;
622 sp<AudioRecordThread> mAudioRecordThread;
623 bool mA2dpEnabled;
The Android Open Source Project22f8def2009-03-09 11:52:12 -0700[diff] [blame]624 bool mNotifyA2dpChange;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]625 mutable int mHardwareStatus;
626 SortedVector< wp<IBinder> > mNotificationClients;
627 int mForcedSpeakerCount;
The Android Open Source Projectbcef13b2009-03-11 12:11:56 -0700[diff] [blame^]628 int mA2dpDisableCount;
629
630 // true if A2DP should resume when mA2dpDisableCount returns to zero
631 bool mA2dpSuppressed;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame]632 uint32_t mSavedRoute;
633 uint32_t mForcedRoute;
634 nsecs_t mRouteRestoreTime;
635 bool mMusicMuteSaved;
636};
637
638// ----------------------------------------------------------------------------
639
640}; // namespace android
641
642#endif // ANDROID_AUDIO_FLINGER_H